vulkan_headers/vulkan/

vulkan_core.rs

use crate::prelude::*;

#[doc(no_inline)]
pub use crate::vk_video::vulkan_video_codec_av1std::*;

#[doc(no_inline)]
pub use crate::vk_video::vulkan_video_codec_av1std_decode::*;

#[doc(no_inline)]
pub use crate::vk_video::vulkan_video_codec_av1std_encode::*;

#[doc(no_inline)]
pub use crate::vk_video::vulkan_video_codec_h264std::*;

#[doc(no_inline)]
pub use crate::vk_video::vulkan_video_codec_h264std_decode::*;

#[doc(no_inline)]
pub use crate::vk_video::vulkan_video_codec_h264std_encode::*;

#[doc(no_inline)]
pub use crate::vk_video::vulkan_video_codec_h265std::*;

#[doc(no_inline)]
pub use crate::vk_video::vulkan_video_codec_h265std_decode::*;

#[doc(no_inline)]
pub use crate::vk_video::vulkan_video_codec_h265std_encode::*;

#[doc(no_inline)]
pub use crate::vk_video::vulkan_video_codec_vp9std::*;

#[doc(no_inline)]
pub use crate::vk_video::vulkan_video_codec_vp9std_decode::*;

#[doc(no_inline)]
pub use crate::vk_video::vulkan_video_codecs_common::*;

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAabbPositionsKHR {
    pub minX: f32,
    pub minY: f32,
    pub minZ: f32,
    pub maxX: f32,
    pub maxY: f32,
    pub maxZ: f32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureBuildGeometryInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub typ: VkAccelerationStructureTypeKHR,
    pub flags: VkBuildAccelerationStructureFlagsKHR,
    pub mode: VkBuildAccelerationStructureModeKHR,
    pub srcAccelerationStructure: VkAccelerationStructureKHR,
    pub dstAccelerationStructure: VkAccelerationStructureKHR,
    pub geometryCount: u32,
    pub pGeometries: *const VkAccelerationStructureGeometryKHR,
    pub ppGeometries: *const *const VkAccelerationStructureGeometryKHR,
    pub scratchData: VkDeviceOrHostAddressKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureBuildRangeInfoKHR {
    pub primitiveCount: u32,
    pub primitiveOffset: u32,
    pub firstVertex: u32,
    pub transformOffset: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureBuildSizesInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub accelerationStructureSize: VkDeviceSize,
    pub updateScratchSize: VkDeviceSize,
    pub buildScratchSize: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureCaptureDescriptorDataInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub accelerationStructure: VkAccelerationStructureKHR,
    pub accelerationStructureNV: VkAccelerationStructureNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub createFlags: VkAccelerationStructureCreateFlagsKHR,
    pub buffer: VkBuffer,
    pub offset: VkDeviceSize,
    pub size: VkDeviceSize,
    pub typ: VkAccelerationStructureTypeKHR,
    pub deviceAddress: VkDeviceAddress,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub compactedSize: VkDeviceSize,
    pub info: VkAccelerationStructureInfoNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureDeviceAddressInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub accelerationStructure: VkAccelerationStructureKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureGeometryAabbsDataKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub data: VkDeviceOrHostAddressConstKHR,
    pub stride: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureGeometryInstancesDataKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub arrayOfPointers: VkBool32,
    pub data: VkDeviceOrHostAddressConstKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureGeometryKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub geometryType: VkGeometryTypeKHR,
    pub geometry: VkAccelerationStructureGeometryDataKHR,
    pub flags: VkGeometryFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureGeometryLinearSweptSpheresDataNV {
    pub sType: VkStructureType,
    pub pNext: *const c_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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureGeometryMotionTrianglesDataNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub vertexData: VkDeviceOrHostAddressConstKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureGeometrySpheresDataNV {
    pub sType: VkStructureType,
    pub pNext: *const c_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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureGeometryTrianglesDataKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub vertexFormat: VkFormat,
    pub vertexData: VkDeviceOrHostAddressConstKHR,
    pub vertexStride: VkDeviceSize,
    pub maxVertex: u32,
    pub indexType: VkIndexType,
    pub indexData: VkDeviceOrHostAddressConstKHR,
    pub transformData: VkDeviceOrHostAddressConstKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub typ: VkAccelerationStructureTypeNV,
    pub flags: VkBuildAccelerationStructureFlagsNV,
    pub instanceCount: u32,
    pub geometryCount: u32,
    pub pGeometries: *const VkGeometryNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureInstanceKHR {
    pub transform: VkTransformMatrixKHR,
    pub bitfields: [u32; 2],
    pub accelerationStructureReference: u64,
}

#[repr(C)]
pub struct VkAccelerationStructureKHR_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureMatrixMotionInstanceNV {
    pub transformT0: VkTransformMatrixKHR,
    pub transformT1: VkTransformMatrixKHR,
    pub bitfields: [u32; 2],
    pub accelerationStructureReference: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureMemoryRequirementsInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub typ: VkAccelerationStructureMemoryRequirementsTypeNV,
    pub accelerationStructure: VkAccelerationStructureNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureMotionInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub maxInstances: u32,
    pub flags: VkAccelerationStructureMotionInfoFlagsNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureMotionInstanceNV {
    pub typ: VkAccelerationStructureMotionInstanceTypeNV,
    pub flags: VkAccelerationStructureMotionInstanceFlagsNV,
    pub data: VkAccelerationStructureMotionInstanceDataNV,
}

#[repr(C)]
pub struct VkAccelerationStructureNV_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureSRTMotionInstanceNV {
    pub transformT0: VkSRTDataNV,
    pub transformT1: VkSRTDataNV,
    pub bitfields: [u32; 2],
    pub accelerationStructureReference: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureTrianglesOpacityMicromapEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub indexType: VkIndexType,
    pub indexBuffer: VkDeviceOrHostAddressConstKHR,
    pub indexStride: VkDeviceSize,
    pub baseTriangle: u32,
    pub usageCountsCount: u32,
    pub pUsageCounts: *const VkMicromapUsageEXT,
    pub ppUsageCounts: *const *const VkMicromapUsageEXT,
    pub micromap: VkMicromapEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAccelerationStructureVersionInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pVersionData: *const u8,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAcquireNextImageInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub swapchain: VkSwapchainKHR,
    pub timeout: u64,
    pub semaphore: VkSemaphore,
    pub fence: VkFence,
    pub deviceMask: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAcquireProfilingLockInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkAcquireProfilingLockFlagsKHR,
    pub timeout: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAllocationCallbacks {
    pub pUserData: *mut c_void,
    pub pfnAllocation: PFN_vkAllocationFunction,
    pub pfnReallocation: PFN_vkReallocationFunction,
    pub pfnFree: PFN_vkFreeFunction,
    pub pfnInternalAllocation: PFN_vkInternalAllocationNotification,
    pub pfnInternalFree: PFN_vkInternalFreeNotification,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAmigoProfilingSubmitInfoSEC {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub firstDrawTimestamp: u64,
    pub swapBufferTimestamp: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAntiLagDataAMD {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub mode: VkAntiLagModeAMD,
    pub maxFPS: u32,
    pub pPresentationInfo: *const VkAntiLagPresentationInfoAMD,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAntiLagPresentationInfoAMD {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub stage: VkAntiLagStageAMD,
    pub frameIndex: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkApplicationInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pApplicationName: *const c_char,
    pub applicationVersion: u32,
    pub pEngineName: *const c_char,
    pub engineVersion: u32,
    pub apiVersion: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAttachmentDescription {
    pub flags: VkAttachmentDescriptionFlags,
    pub format: VkFormat,
    pub samples: VkSampleCountFlagBits,
    pub loadOp: VkAttachmentLoadOp,
    pub storeOp: VkAttachmentStoreOp,
    pub stencilLoadOp: VkAttachmentLoadOp,
    pub stencilStoreOp: VkAttachmentStoreOp,
    pub initialLayout: VkImageLayout,
    pub finalLayout: VkImageLayout,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAttachmentDescription2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkAttachmentDescriptionFlags,
    pub format: VkFormat,
    pub samples: VkSampleCountFlagBits,
    pub loadOp: VkAttachmentLoadOp,
    pub storeOp: VkAttachmentStoreOp,
    pub stencilLoadOp: VkAttachmentLoadOp,
    pub stencilStoreOp: VkAttachmentStoreOp,
    pub initialLayout: VkImageLayout,
    pub finalLayout: VkImageLayout,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAttachmentDescriptionStencilLayout {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub stencilInitialLayout: VkImageLayout,
    pub stencilFinalLayout: VkImageLayout,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAttachmentFeedbackLoopInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub feedbackLoopEnable: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAttachmentReference {
    pub attachment: u32,
    pub layout: VkImageLayout,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAttachmentReference2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub attachment: u32,
    pub layout: VkImageLayout,
    pub aspectMask: VkImageAspectFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAttachmentReferenceStencilLayout {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub stencilLayout: VkImageLayout,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAttachmentSampleCountInfoAMD {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub colorAttachmentCount: u32,
    pub pColorAttachmentSamples: *const VkSampleCountFlagBits,
    pub depthStencilAttachmentSamples: VkSampleCountFlagBits,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkAttachmentSampleLocationsEXT {
    pub attachmentIndex: u32,
    pub sampleLocationsInfo: VkSampleLocationsInfoEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBaseInStructure {
    pub sType: VkStructureType,
    pub pNext: *const VkBaseInStructure,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBaseOutStructure {
    pub sType: VkStructureType,
    pub pNext: *mut VkBaseOutStructure,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBeginCustomResolveInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindAccelerationStructureMemoryInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub accelerationStructure: VkAccelerationStructureNV,
    pub memory: VkDeviceMemory,
    pub memoryOffset: VkDeviceSize,
    pub deviceIndexCount: u32,
    pub pDeviceIndices: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindBufferMemoryDeviceGroupInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub deviceIndexCount: u32,
    pub pDeviceIndices: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindBufferMemoryInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub buffer: VkBuffer,
    pub memory: VkDeviceMemory,
    pub memoryOffset: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindDataGraphPipelineSessionMemoryInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub session: VkDataGraphPipelineSessionARM,
    pub bindPoint: VkDataGraphPipelineSessionBindPointARM,
    pub objectIndex: u32,
    pub memory: VkDeviceMemory,
    pub memoryOffset: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stageFlags: VkShaderStageFlags,
    pub layout: VkPipelineLayout,
    pub set: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindDescriptorSetsInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stageFlags: VkShaderStageFlags,
    pub layout: VkPipelineLayout,
    pub firstSet: u32,
    pub descriptorSetCount: u32,
    pub pDescriptorSets: *const VkDescriptorSet,
    pub dynamicOffsetCount: u32,
    pub pDynamicOffsets: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindImageMemoryDeviceGroupInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub deviceIndexCount: u32,
    pub pDeviceIndices: *const u32,
    pub splitInstanceBindRegionCount: u32,
    pub pSplitInstanceBindRegions: *const VkRect2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindImageMemoryInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub image: VkImage,
    pub memory: VkDeviceMemory,
    pub memoryOffset: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindImageMemorySwapchainInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub swapchain: VkSwapchainKHR,
    pub imageIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindImagePlaneMemoryInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub planeAspect: VkImageAspectFlagBits,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindIndexBufferIndirectCommandEXT {
    pub bufferAddress: VkDeviceAddress,
    pub size: u32,
    pub indexType: VkIndexType,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindIndexBufferIndirectCommandNV {
    pub bufferAddress: VkDeviceAddress,
    pub size: u32,
    pub indexType: VkIndexType,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindMemoryStatus {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pResult: *mut VkResult,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindPipelineIndirectCommandNV {
    pub pipelineAddress: VkDeviceAddress,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindShaderGroupIndirectCommandNV {
    pub groupIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindSparseInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub waitSemaphoreCount: u32,
    pub pWaitSemaphores: *const VkSemaphore,
    pub bufferBindCount: u32,
    pub pBufferBinds: *const VkSparseBufferMemoryBindInfo,
    pub imageOpaqueBindCount: u32,
    pub pImageOpaqueBinds: *const VkSparseImageOpaqueMemoryBindInfo,
    pub imageBindCount: u32,
    pub pImageBinds: *const VkSparseImageMemoryBindInfo,
    pub signalSemaphoreCount: u32,
    pub pSignalSemaphores: *const VkSemaphore,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindTensorMemoryInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub tensor: VkTensorARM,
    pub memory: VkDeviceMemory,
    pub memoryOffset: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindVertexBufferIndirectCommandEXT {
    pub bufferAddress: VkDeviceAddress,
    pub size: u32,
    pub stride: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindVertexBufferIndirectCommandNV {
    pub bufferAddress: VkDeviceAddress,
    pub size: u32,
    pub stride: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBindVideoSessionMemoryInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub memoryBindIndex: u32,
    pub memory: VkDeviceMemory,
    pub memoryOffset: VkDeviceSize,
    pub memorySize: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBlitImageCubicWeightsInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub cubicWeights: VkCubicFilterWeightsQCOM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBlitImageInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcImage: VkImage,
    pub srcImageLayout: VkImageLayout,
    pub dstImage: VkImage,
    pub dstImageLayout: VkImageLayout,
    pub regionCount: u32,
    pub pRegions: *const VkImageBlit2,
    pub filter: VkFilter,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBufferCaptureDescriptorDataInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub buffer: VkBuffer,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBufferCopy {
    pub srcOffset: VkDeviceSize,
    pub dstOffset: VkDeviceSize,
    pub size: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBufferCopy2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcOffset: VkDeviceSize,
    pub dstOffset: VkDeviceSize,
    pub size: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBufferCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkBufferCreateFlags,
    pub size: VkDeviceSize,
    pub usage: VkBufferUsageFlags,
    pub sharingMode: VkSharingMode,
    pub queueFamilyIndexCount: u32,
    pub pQueueFamilyIndices: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBufferDeviceAddressCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub deviceAddress: VkDeviceAddress,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBufferDeviceAddressInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub buffer: VkBuffer,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBufferImageCopy {
    pub bufferOffset: VkDeviceSize,
    pub bufferRowLength: u32,
    pub bufferImageHeight: u32,
    pub imageSubresource: VkImageSubresourceLayers,
    pub imageOffset: VkOffset3D,
    pub imageExtent: VkExtent3D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBufferImageCopy2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub bufferOffset: VkDeviceSize,
    pub bufferRowLength: u32,
    pub bufferImageHeight: u32,
    pub imageSubresource: VkImageSubresourceLayers,
    pub imageOffset: VkOffset3D,
    pub imageExtent: VkExtent3D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBufferMemoryBarrier {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcAccessMask: VkAccessFlags,
    pub dstAccessMask: VkAccessFlags,
    pub srcQueueFamilyIndex: u32,
    pub dstQueueFamilyIndex: u32,
    pub buffer: VkBuffer,
    pub offset: VkDeviceSize,
    pub size: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBufferMemoryBarrier2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcStageMask: VkPipelineStageFlags2,
    pub srcAccessMask: VkAccessFlags2,
    pub dstStageMask: VkPipelineStageFlags2,
    pub dstAccessMask: VkAccessFlags2,
    pub srcQueueFamilyIndex: u32,
    pub dstQueueFamilyIndex: u32,
    pub buffer: VkBuffer,
    pub offset: VkDeviceSize,
    pub size: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBufferMemoryRequirementsInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub buffer: VkBuffer,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBufferOpaqueCaptureAddressCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub opaqueCaptureAddress: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBufferUsageFlags2CreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub usage: VkBufferUsageFlags2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBufferViewCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkBufferViewCreateFlags,
    pub buffer: VkBuffer,
    pub format: VkFormat,
    pub offset: VkDeviceSize,
    pub range: VkDeviceSize,
}

#[repr(C)]
pub struct VkBufferView_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[repr(C)]
pub struct VkBuffer_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBuildPartitionedAccelerationStructureIndirectCommandNV {
    pub opType: VkPartitionedAccelerationStructureOpTypeNV,
    pub argCount: u32,
    pub argData: VkStridedDeviceAddressNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkBuildPartitionedAccelerationStructureInfoNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub input: VkPartitionedAccelerationStructureInstancesInputNV,
    pub srcAccelerationStructureData: VkDeviceAddress,
    pub dstAccelerationStructureData: VkDeviceAddress,
    pub scratchData: VkDeviceAddress,
    pub srcInfos: VkDeviceAddress,
    pub srcInfosCount: VkDeviceAddress,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCalibratedTimestampInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub timeDomain: VkTimeDomainKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCheckpointData2NV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub stage: VkPipelineStageFlags2,
    pub pCheckpointMarker: *mut c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCheckpointDataNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub stage: VkPipelineStageFlagBits,
    pub pCheckpointMarker: *mut c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkClearAttachment {
    pub aspectMask: VkImageAspectFlags,
    pub colorAttachment: u32,
    pub clearValue: VkClearValue,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkClearDepthStencilValue {
    pub depth: f32,
    pub stencil: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkClearRect {
    pub rect: VkRect2D,
    pub baseArrayLayer: u32,
    pub layerCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV {
    pub clusterReferencesCount: u32,
    pub clusterReferencesStride: u32,
    pub clusterReferences: VkDeviceAddress,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkClusterAccelerationStructureBuildTriangleClusterInfoNV {
    pub clusterID: u32,
    pub clusterFlags: VkClusterAccelerationStructureClusterFlagsNV,
    pub bitfields: u32,
    pub baseGeometryIndexAndGeometryFlags: VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV,
    pub indexBufferStride: u16,
    pub vertexBufferStride: u16,
    pub geometryIndexAndFlagsBufferStride: u16,
    pub opacityMicromapIndexBufferStride: u16,
    pub indexBuffer: VkDeviceAddress,
    pub vertexBuffer: VkDeviceAddress,
    pub geometryIndexAndFlagsBuffer: VkDeviceAddress,
    pub opacityMicromapArray: VkDeviceAddress,
    pub opacityMicromapIndexBuffer: VkDeviceAddress,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV {
    pub clusterID: u32,
    pub clusterFlags: VkClusterAccelerationStructureClusterFlagsNV,
    pub bitfields: u32,
    pub baseGeometryIndexAndGeometryFlags: VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV,
    pub indexBufferStride: u16,
    pub vertexBufferStride: u16,
    pub geometryIndexAndFlagsBufferStride: u16,
    pub opacityMicromapIndexBufferStride: u16,
    pub indexBuffer: VkDeviceAddress,
    pub vertexBuffer: VkDeviceAddress,
    pub geometryIndexAndFlagsBuffer: VkDeviceAddress,
    pub opacityMicromapArray: VkDeviceAddress,
    pub opacityMicromapIndexBuffer: VkDeviceAddress,
    pub instantiationBoundingBoxLimit: VkDeviceAddress,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkClusterAccelerationStructureClustersBottomLevelInputNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxTotalClusterCount: u32,
    pub maxClusterCountPerAccelerationStructure: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkClusterAccelerationStructureCommandsInfoNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV {
    pub bitfields: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkClusterAccelerationStructureGetTemplateIndicesInfoNV {
    pub clusterTemplateAddress: VkDeviceAddress,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkClusterAccelerationStructureInputInfoNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxAccelerationStructureCount: u32,
    pub flags: VkBuildAccelerationStructureFlagsKHR,
    pub opType: VkClusterAccelerationStructureOpTypeNV,
    pub opMode: VkClusterAccelerationStructureOpModeNV,
    pub opInput: VkClusterAccelerationStructureOpInputNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkClusterAccelerationStructureInstantiateClusterInfoNV {
    pub clusterIdOffset: u32,
    pub bitfields: u32,
    pub clusterTemplateAddress: VkDeviceAddress,
    pub vertexBuffer: VkStridedDeviceAddressNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkClusterAccelerationStructureMoveObjectsInfoNV {
    pub srcAccelerationStructure: VkDeviceAddress,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkClusterAccelerationStructureMoveObjectsInputNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub typ: VkClusterAccelerationStructureTypeNV,
    pub noMoveOverlap: VkBool32,
    pub maxMovedBytes: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkClusterAccelerationStructureTriangleClusterInputNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub vertexFormat: VkFormat,
    pub maxGeometryIndexValue: u32,
    pub maxClusterUniqueGeometryCount: u32,
    pub maxClusterTriangleCount: u32,
    pub maxClusterVertexCount: u32,
    pub maxTotalTriangleCount: u32,
    pub maxTotalVertexCount: u32,
    pub minPositionTruncateBitCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCoarseSampleLocationNV {
    pub pixelX: u32,
    pub pixelY: u32,
    pub sample: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCoarseSampleOrderCustomNV {
    pub shadingRate: VkShadingRatePaletteEntryNV,
    pub sampleCount: u32,
    pub sampleLocationCount: u32,
    pub pSampleLocations: *const VkCoarseSampleLocationNV,
}

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

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

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCommandBufferAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub commandPool: VkCommandPool,
    pub level: VkCommandBufferLevel,
    pub commandBufferCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCommandBufferBeginInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkCommandBufferUsageFlags,
    pub pInheritanceInfo: *const VkCommandBufferInheritanceInfo,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCommandBufferInheritanceConditionalRenderingInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub conditionalRenderingEnable: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCommandBufferInheritanceInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub renderPass: VkRenderPass,
    pub subpass: u32,
    pub framebuffer: VkFramebuffer,
    pub occlusionQueryEnable: VkBool32,
    pub queryFlags: VkQueryControlFlags,
    pub pipelineStatistics: VkQueryPipelineStatisticFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub transform: VkSurfaceTransformFlagBitsKHR,
    pub renderArea: VkRect2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCommandBufferInheritanceRenderingInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkRenderingFlags,
    pub viewMask: u32,
    pub colorAttachmentCount: u32,
    pub pColorAttachmentFormats: *const VkFormat,
    pub depthAttachmentFormat: VkFormat,
    pub stencilAttachmentFormat: VkFormat,
    pub rasterizationSamples: VkSampleCountFlagBits,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCommandBufferInheritanceViewportScissorInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub viewportScissor2D: VkBool32,
    pub viewportDepthCount: u32,
    pub pViewportDepths: *const VkViewport,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCommandBufferSubmitInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub commandBuffer: VkCommandBuffer,
    pub deviceMask: u32,
}

#[repr(C)]
pub struct VkCommandBuffer_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCommandPoolCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkCommandPoolCreateFlags,
    pub queueFamilyIndex: u32,
}

#[repr(C)]
pub struct VkCommandPool_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkComponentMapping {
    pub r: VkComponentSwizzle,
    pub g: VkComponentSwizzle,
    pub b: VkComponentSwizzle,
    pub a: VkComponentSwizzle,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkComputeOccupancyPriorityParametersNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub occupancyPriority: f32,
    pub occupancyThrottling: f32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkComputePipelineCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineCreateFlags,
    pub stage: VkPipelineShaderStageCreateInfo,
    pub layout: VkPipelineLayout,
    pub basePipelineHandle: VkPipeline,
    pub basePipelineIndex: i32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkComputePipelineIndirectBufferInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub deviceAddress: VkDeviceAddress,
    pub size: VkDeviceSize,
    pub pipelineDeviceAddressCaptureReplay: VkDeviceAddress,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkConditionalRenderingBeginInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub buffer: VkBuffer,
    pub offset: VkDeviceSize,
    pub flags: VkConditionalRenderingFlagsEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkConformanceVersion {
    pub major: u8,
    pub minor: u8,
    pub subminor: u8,
    pub patch: u8,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkConvertCooperativeVectorMatrixInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcSize: usize,
    pub srcData: VkDeviceOrHostAddressConstKHR,
    pub pDstSize: *mut usize,
    pub dstData: VkDeviceOrHostAddressKHR,
    pub srcComponentType: VkComponentTypeKHR,
    pub dstComponentType: VkComponentTypeKHR,
    pub numRows: u32,
    pub numColumns: u32,
    pub srcLayout: VkCooperativeVectorMatrixLayoutNV,
    pub srcStride: usize,
    pub dstLayout: VkCooperativeVectorMatrixLayoutNV,
    pub dstStride: usize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCooperativeMatrixFlexibleDimensionsPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub MGranularity: u32,
    pub NGranularity: u32,
    pub KGranularity: u32,
    pub AType: VkComponentTypeKHR,
    pub BType: VkComponentTypeKHR,
    pub CType: VkComponentTypeKHR,
    pub ResultType: VkComponentTypeKHR,
    pub saturatingAccumulation: VkBool32,
    pub scope: VkScopeKHR,
    pub workgroupInvocations: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCooperativeMatrixPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub MSize: u32,
    pub NSize: u32,
    pub KSize: u32,
    pub AType: VkComponentTypeKHR,
    pub BType: VkComponentTypeKHR,
    pub CType: VkComponentTypeKHR,
    pub ResultType: VkComponentTypeKHR,
    pub saturatingAccumulation: VkBool32,
    pub scope: VkScopeKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCooperativeMatrixPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub MSize: u32,
    pub NSize: u32,
    pub KSize: u32,
    pub AType: VkComponentTypeNV,
    pub BType: VkComponentTypeNV,
    pub CType: VkComponentTypeNV,
    pub DType: VkComponentTypeNV,
    pub scope: VkScopeNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCooperativeVectorPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub inputType: VkComponentTypeKHR,
    pub inputInterpretation: VkComponentTypeKHR,
    pub matrixInterpretation: VkComponentTypeKHR,
    pub biasInterpretation: VkComponentTypeKHR,
    pub resultType: VkComponentTypeKHR,
    pub transpose: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyAccelerationStructureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub src: VkAccelerationStructureKHR,
    pub dst: VkAccelerationStructureKHR,
    pub mode: VkCopyAccelerationStructureModeKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyAccelerationStructureToMemoryInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub src: VkAccelerationStructureKHR,
    pub dst: VkDeviceOrHostAddressKHR,
    pub mode: VkCopyAccelerationStructureModeKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyBufferInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcBuffer: VkBuffer,
    pub dstBuffer: VkBuffer,
    pub regionCount: u32,
    pub pRegions: *const VkBufferCopy2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyBufferToImageInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcBuffer: VkBuffer,
    pub dstImage: VkImage,
    pub dstImageLayout: VkImageLayout,
    pub regionCount: u32,
    pub pRegions: *const VkBufferImageCopy2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyCommandTransformInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub transform: VkSurfaceTransformFlagBitsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyDescriptorSet {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcSet: VkDescriptorSet,
    pub srcBinding: u32,
    pub srcArrayElement: u32,
    pub dstSet: VkDescriptorSet,
    pub dstBinding: u32,
    pub dstArrayElement: u32,
    pub descriptorCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyImageInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcImage: VkImage,
    pub srcImageLayout: VkImageLayout,
    pub dstImage: VkImage,
    pub dstImageLayout: VkImageLayout,
    pub regionCount: u32,
    pub pRegions: *const VkImageCopy2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyImageToBufferInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcImage: VkImage,
    pub srcImageLayout: VkImageLayout,
    pub dstBuffer: VkBuffer,
    pub regionCount: u32,
    pub pRegions: *const VkBufferImageCopy2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyImageToImageInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkHostImageCopyFlags,
    pub srcImage: VkImage,
    pub srcImageLayout: VkImageLayout,
    pub dstImage: VkImage,
    pub dstImageLayout: VkImageLayout,
    pub regionCount: u32,
    pub pRegions: *const VkImageCopy2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyImageToMemoryInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkHostImageCopyFlags,
    pub srcImage: VkImage,
    pub srcImageLayout: VkImageLayout,
    pub regionCount: u32,
    pub pRegions: *const VkImageToMemoryCopy,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyMemoryIndirectCommandKHR {
    pub srcAddress: VkDeviceAddress,
    pub dstAddress: VkDeviceAddress,
    pub size: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyMemoryIndirectInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcCopyFlags: VkAddressCopyFlagsKHR,
    pub dstCopyFlags: VkAddressCopyFlagsKHR,
    pub copyCount: u32,
    pub copyAddressRange: VkStridedDeviceAddressRangeKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyMemoryToAccelerationStructureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub src: VkDeviceOrHostAddressConstKHR,
    pub dst: VkAccelerationStructureKHR,
    pub mode: VkCopyAccelerationStructureModeKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyMemoryToImageIndirectCommandKHR {
    pub srcAddress: VkDeviceAddress,
    pub bufferRowLength: u32,
    pub bufferImageHeight: u32,
    pub imageSubresource: VkImageSubresourceLayers,
    pub imageOffset: VkOffset3D,
    pub imageExtent: VkExtent3D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyMemoryToImageIndirectInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcCopyFlags: VkAddressCopyFlagsKHR,
    pub copyCount: u32,
    pub copyAddressRange: VkStridedDeviceAddressRangeKHR,
    pub dstImage: VkImage,
    pub dstImageLayout: VkImageLayout,
    pub pImageSubresources: *const VkImageSubresourceLayers,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyMemoryToImageInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkHostImageCopyFlags,
    pub dstImage: VkImage,
    pub dstImageLayout: VkImageLayout,
    pub regionCount: u32,
    pub pRegions: *const VkMemoryToImageCopy,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyMemoryToMicromapInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub src: VkDeviceOrHostAddressConstKHR,
    pub dst: VkMicromapEXT,
    pub mode: VkCopyMicromapModeEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyMicromapInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub src: VkMicromapEXT,
    pub dst: VkMicromapEXT,
    pub mode: VkCopyMicromapModeEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyMicromapToMemoryInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub src: VkMicromapEXT,
    pub dst: VkDeviceOrHostAddressKHR,
    pub mode: VkCopyMicromapModeEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCopyTensorInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcTensor: VkTensorARM,
    pub dstTensor: VkTensorARM,
    pub regionCount: u32,
    pub pRegions: *const VkTensorCopyARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCuFunctionCreateInfoNVX {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub module: VkCuModuleNVX,
    pub pName: *const c_char,
}

#[repr(C)]
pub struct VkCuFunctionNVX_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCuLaunchInfoNVX {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub function: VkCuFunctionNVX,
    pub gridDimX: u32,
    pub gridDimY: u32,
    pub gridDimZ: u32,
    pub blockDimX: u32,
    pub blockDimY: u32,
    pub blockDimZ: u32,
    pub sharedMemBytes: u32,
    pub paramCount: usize,
    pub pParams: *const *const c_void,
    pub extraCount: usize,
    pub pExtras: *const *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCuModuleCreateInfoNVX {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub dataSize: usize,
    pub pData: *const c_void,
}

#[repr(C)]
pub struct VkCuModuleNVX_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCuModuleTexturingModeCreateInfoNVX {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub use64bitTexturing: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkCustomResolveCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub customResolve: VkBool32,
    pub colorAttachmentCount: u32,
    pub pColorAttachmentFormats: *const VkFormat,
    pub depthAttachmentFormat: VkFormat,
    pub stencilAttachmentFormat: VkFormat,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDataGraphPipelineBuiltinModelCreateInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pOperation: *const VkPhysicalDeviceDataGraphOperationSupportARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDataGraphPipelineCompilerControlCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pVendorOptions: *const c_char,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDataGraphPipelineConstantARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub id: u32,
    pub pConstantData: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub dimension: u32,
    pub zeroCount: u32,
    pub groupSize: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDataGraphPipelineCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineCreateFlags2KHR,
    pub layout: VkPipelineLayout,
    pub resourceInfoCount: u32,
    pub pResourceInfos: *const VkDataGraphPipelineResourceInfoARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDataGraphPipelineDispatchInfoARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub flags: VkDataGraphPipelineDispatchFlagsARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDataGraphPipelineIdentifierCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub identifierSize: u32,
    pub pIdentifier: *const u8,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDataGraphPipelineInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub dataGraphPipeline: VkPipeline,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDataGraphPipelinePropertyQueryResultARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub property: VkDataGraphPipelinePropertyARM,
    pub isText: VkBool32,
    pub dataSize: usize,
    pub pData: *mut c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDataGraphPipelineResourceInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub descriptorSet: u32,
    pub binding: u32,
    pub arrayElement: u32,
}

#[repr(C)]
pub struct VkDataGraphPipelineSessionARM_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDataGraphPipelineSessionBindPointRequirementARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub bindPoint: VkDataGraphPipelineSessionBindPointARM,
    pub bindPointType: VkDataGraphPipelineSessionBindPointTypeARM,
    pub numObjects: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub session: VkDataGraphPipelineSessionARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDataGraphPipelineSessionCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDataGraphPipelineSessionCreateFlagsARM,
    pub dataGraphPipeline: VkPipeline,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub session: VkDataGraphPipelineSessionARM,
    pub bindPoint: VkDataGraphPipelineSessionBindPointARM,
    pub objectIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDataGraphPipelineShaderModuleCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub module: VkShaderModule,
    pub pName: *const c_char,
    pub pSpecializationInfo: *const VkSpecializationInfo,
    pub constantCount: u32,
    pub pConstants: *const VkDataGraphPipelineConstantARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDataGraphProcessingEngineCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub processingEngineCount: u32,
    pub pProcessingEngines: *mut VkPhysicalDeviceDataGraphProcessingEngineARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDebugMarkerMarkerInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pMarkerName: *const c_char,
    pub color: [f32; 4 as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDebugMarkerObjectNameInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub objectType: VkDebugReportObjectTypeEXT,
    pub object: u64,
    pub pObjectName: *const c_char,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDebugMarkerObjectTagInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub objectType: VkDebugReportObjectTypeEXT,
    pub object: u64,
    pub tagName: u64,
    pub tagSize: usize,
    pub pTag: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDebugReportCallbackCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDebugReportFlagsEXT,
    pub pfnCallback: PFN_vkDebugReportCallbackEXT,
    pub pUserData: *mut c_void,
}

#[repr(C)]
pub struct VkDebugReportCallbackEXT_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDebugUtilsLabelEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pLabelName: *const c_char,
    pub color: [f32; 4 as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDebugUtilsMessengerCallbackDataEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDebugUtilsMessengerCallbackDataFlagsEXT,
    pub pMessageIdName: *const c_char,
    pub messageIdNumber: i32,
    pub pMessage: *const c_char,
    pub queueLabelCount: u32,
    pub pQueueLabels: *const VkDebugUtilsLabelEXT,
    pub cmdBufLabelCount: u32,
    pub pCmdBufLabels: *const VkDebugUtilsLabelEXT,
    pub objectCount: u32,
    pub pObjects: *const VkDebugUtilsObjectNameInfoEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDebugUtilsMessengerCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDebugUtilsMessengerCreateFlagsEXT,
    pub messageSeverity: VkDebugUtilsMessageSeverityFlagsEXT,
    pub messageType: VkDebugUtilsMessageTypeFlagsEXT,
    pub pfnUserCallback: PFN_vkDebugUtilsMessengerCallbackEXT,
    pub pUserData: *mut c_void,
}

#[repr(C)]
pub struct VkDebugUtilsMessengerEXT_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDebugUtilsObjectNameInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub objectType: VkObjectType,
    pub objectHandle: u64,
    pub pObjectName: *const c_char,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDebugUtilsObjectTagInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub objectType: VkObjectType,
    pub objectHandle: u64,
    pub tagName: u64,
    pub tagSize: usize,
    pub pTag: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDecompressMemoryInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub decompressionMethod: VkMemoryDecompressionMethodFlagsEXT,
    pub regionCount: u32,
    pub pRegions: *const VkDecompressMemoryRegionEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDecompressMemoryRegionEXT {
    pub srcAddress: VkDeviceAddress,
    pub dstAddress: VkDeviceAddress,
    pub compressedSize: VkDeviceSize,
    pub decompressedSize: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDecompressMemoryRegionNV {
    pub srcAddress: VkDeviceAddress,
    pub dstAddress: VkDeviceAddress,
    pub compressedSize: VkDeviceSize,
    pub decompressedSize: VkDeviceSize,
    pub decompressionMethod: VkMemoryDecompressionMethodFlagsNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDedicatedAllocationBufferCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub dedicatedAllocation: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDedicatedAllocationImageCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub dedicatedAllocation: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDedicatedAllocationMemoryAllocateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub image: VkImage,
    pub buffer: VkBuffer,
}

#[repr(C)]
pub struct VkDeferredOperationKHR_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDependencyInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub dependencyFlags: VkDependencyFlags,
    pub memoryBarrierCount: u32,
    pub pMemoryBarriers: *const VkMemoryBarrier2,
    pub bufferMemoryBarrierCount: u32,
    pub pBufferMemoryBarriers: *const VkBufferMemoryBarrier2,
    pub imageMemoryBarrierCount: u32,
    pub pImageMemoryBarriers: *const VkImageMemoryBarrier2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDepthBiasInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub depthBiasConstantFactor: f32,
    pub depthBiasClamp: f32,
    pub depthBiasSlopeFactor: f32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDepthBiasRepresentationInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub depthBiasRepresentation: VkDepthBiasRepresentationEXT,
    pub depthBiasExact: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDepthClampRangeEXT {
    pub minDepthClamp: f32,
    pub maxDepthClamp: f32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorAddressInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub address: VkDeviceAddress,
    pub range: VkDeviceSize,
    pub format: VkFormat,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorBufferBindingInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub address: VkDeviceAddress,
    pub usage: VkBufferUsageFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub buffer: VkBuffer,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorBufferInfo {
    pub buffer: VkBuffer,
    pub offset: VkDeviceSize,
    pub range: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorGetInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub typ: VkDescriptorType,
    pub data: VkDescriptorDataEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorGetTensorInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub tensorView: VkTensorViewARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorImageInfo {
    pub sampler: VkSampler,
    pub imageView: VkImageView,
    pub imageLayout: VkImageLayout,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorPoolCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDescriptorPoolCreateFlags,
    pub maxSets: u32,
    pub poolSizeCount: u32,
    pub pPoolSizes: *const VkDescriptorPoolSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorPoolInlineUniformBlockCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub maxInlineUniformBlockBindings: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorPoolSize {
    pub typ: VkDescriptorType,
    pub descriptorCount: u32,
}

#[repr(C)]
pub struct VkDescriptorPool_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorSetAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub descriptorPool: VkDescriptorPool,
    pub descriptorSetCount: u32,
    pub pSetLayouts: *const VkDescriptorSetLayout,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorSetBindingReferenceVALVE {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub descriptorSetLayout: VkDescriptorSetLayout,
    pub binding: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorSetLayoutBinding {
    pub binding: u32,
    pub descriptorType: VkDescriptorType,
    pub descriptorCount: u32,
    pub stageFlags: VkShaderStageFlags,
    pub pImmutableSamplers: *const VkSampler,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorSetLayoutBindingFlagsCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub bindingCount: u32,
    pub pBindingFlags: *const VkDescriptorBindingFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorSetLayoutCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDescriptorSetLayoutCreateFlags,
    pub bindingCount: u32,
    pub pBindings: *const VkDescriptorSetLayoutBinding,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorSetLayoutHostMappingInfoVALVE {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub descriptorOffset: usize,
    pub descriptorSize: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorSetLayoutSupport {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub supported: VkBool32,
}

#[repr(C)]
pub struct VkDescriptorSetLayout_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorSetVariableDescriptorCountAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub descriptorSetCount: u32,
    pub pDescriptorCounts: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorSetVariableDescriptorCountLayoutSupport {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxVariableDescriptorCount: u32,
}

#[repr(C)]
pub struct VkDescriptorSet_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorUpdateTemplateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDescriptorUpdateTemplateCreateFlags,
    pub descriptorUpdateEntryCount: u32,
    pub pDescriptorUpdateEntries: *const VkDescriptorUpdateTemplateEntry,
    pub templateType: VkDescriptorUpdateTemplateType,
    pub descriptorSetLayout: VkDescriptorSetLayout,
    pub pipelineBindPoint: VkPipelineBindPoint,
    pub pipelineLayout: VkPipelineLayout,
    pub set: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDescriptorUpdateTemplateEntry {
    pub dstBinding: u32,
    pub dstArrayElement: u32,
    pub descriptorCount: u32,
    pub descriptorType: VkDescriptorType,
    pub offset: usize,
    pub stride: usize,
}

#[repr(C)]
pub struct VkDescriptorUpdateTemplate_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceAddressBindingCallbackDataEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub flags: VkDeviceAddressBindingFlagsEXT,
    pub baseAddress: VkDeviceAddress,
    pub size: VkDeviceSize,
    pub bindingType: VkDeviceAddressBindingTypeEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceBufferMemoryRequirements {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pCreateInfo: *const VkBufferCreateInfo,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDeviceCreateFlags,
    pub queueCreateInfoCount: u32,
    pub pQueueCreateInfos: *const VkDeviceQueueCreateInfo,
    pub enabledLayerCount: u32,
    pub ppEnabledLayerNames: *const *const c_char,
    pub enabledExtensionCount: u32,
    pub ppEnabledExtensionNames: *const *const c_char,
    pub pEnabledFeatures: *const VkPhysicalDeviceFeatures,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceDeviceMemoryReportCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDeviceMemoryReportFlagsEXT,
    pub pfnUserCallback: PFN_vkDeviceMemoryReportCallbackEXT,
    pub pUserData: *mut c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceDiagnosticsConfigCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDeviceDiagnosticsConfigFlagsNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceEventInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub deviceEvent: VkDeviceEventTypeEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceFaultAddressInfoEXT {
    pub addressType: VkDeviceFaultAddressTypeEXT,
    pub reportedAddress: VkDeviceAddress,
    pub addressPrecision: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceFaultCountsEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub addressInfoCount: u32,
    pub vendorInfoCount: u32,
    pub vendorBinarySize: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceFaultInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
    pub pAddressInfos: *mut VkDeviceFaultAddressInfoEXT,
    pub pVendorInfos: *mut VkDeviceFaultVendorInfoEXT,
    pub pVendorBinaryData: *mut c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT {
    pub headerSize: u32,
    pub headerVersion: VkDeviceFaultVendorBinaryHeaderVersionEXT,
    pub vendorID: u32,
    pub deviceID: u32,
    pub driverVersion: u32,
    pub pipelineCacheUUID: [u8; VK_UUID_SIZE as usize],
    pub applicationNameOffset: u32,
    pub applicationVersion: u32,
    pub engineNameOffset: u32,
    pub engineVersion: u32,
    pub apiVersion: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceFaultVendorInfoEXT {
    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
    pub vendorFaultCode: u64,
    pub vendorFaultData: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceGroupBindSparseInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub resourceDeviceIndex: u32,
    pub memoryDeviceIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceGroupCommandBufferBeginInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub deviceMask: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceGroupDeviceCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub physicalDeviceCount: u32,
    pub pPhysicalDevices: *const VkPhysicalDevice,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceGroupPresentCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentMask: [u32; VK_MAX_DEVICE_GROUP_SIZE as usize],
    pub modes: VkDeviceGroupPresentModeFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceGroupPresentInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub swapchainCount: u32,
    pub pDeviceMasks: *const u32,
    pub mode: VkDeviceGroupPresentModeFlagBitsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceGroupRenderPassBeginInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub deviceMask: u32,
    pub deviceRenderAreaCount: u32,
    pub pDeviceRenderAreas: *const VkRect2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceGroupSubmitInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub waitSemaphoreCount: u32,
    pub pWaitSemaphoreDeviceIndices: *const u32,
    pub commandBufferCount: u32,
    pub pCommandBufferDeviceMasks: *const u32,
    pub signalSemaphoreCount: u32,
    pub pSignalSemaphoreDeviceIndices: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceGroupSwapchainCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub modes: VkDeviceGroupPresentModeFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceImageMemoryRequirements {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pCreateInfo: *const VkImageCreateInfo,
    pub planeAspect: VkImageAspectFlagBits,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceImageSubresourceInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pCreateInfo: *const VkImageCreateInfo,
    pub pSubresource: *const VkImageSubresource2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceMemoryOpaqueCaptureAddressInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub memory: VkDeviceMemory,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceMemoryOverallocationCreateInfoAMD {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub overallocationBehavior: VkMemoryOverallocationBehaviorAMD,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceMemoryReportCallbackDataEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub flags: VkDeviceMemoryReportFlagsEXT,
    pub typ: VkDeviceMemoryReportEventTypeEXT,
    pub memoryObjectId: u64,
    pub size: VkDeviceSize,
    pub objectType: VkObjectType,
    pub objectHandle: u64,
    pub heapIndex: u32,
}

#[repr(C)]
pub struct VkDeviceMemory_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDevicePipelineBinaryInternalCacheControlKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub disableInternalCache: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDevicePrivateDataCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub privateDataSlotRequestCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceQueueCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDeviceQueueCreateFlags,
    pub queueFamilyIndex: u32,
    pub queueCount: u32,
    pub pQueuePriorities: *const f32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceQueueGlobalPriorityCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub globalPriority: VkQueueGlobalPriority,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceQueueInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDeviceQueueCreateFlags,
    pub queueFamilyIndex: u32,
    pub queueIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceQueueShaderCoreControlCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderCoreCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDeviceTensorMemoryRequirementsARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pCreateInfo: *const VkTensorCreateInfoARM,
}

#[repr(C)]
pub struct VkDevice_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDirectDriverLoadingInfoLUNARG {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub flags: VkDirectDriverLoadingFlagsLUNARG,
    pub pfnGetInstanceProcAddr: PFN_vkGetInstanceProcAddrLUNARG,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDirectDriverLoadingListLUNARG {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub mode: VkDirectDriverLoadingModeLUNARG,
    pub driverCount: u32,
    pub pDrivers: *const VkDirectDriverLoadingInfoLUNARG,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDispatchIndirectCommand {
    pub x: u32,
    pub y: u32,
    pub z: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDispatchTileInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplayEventInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub displayEvent: VkDisplayEventTypeEXT,
}

#[repr(C)]
pub struct VkDisplayKHR_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplayModeCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDisplayModeCreateFlagsKHR,
    pub parameters: VkDisplayModeParametersKHR,
}

#[repr(C)]
pub struct VkDisplayModeKHR_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplayModeParametersKHR {
    pub visibleRegion: VkExtent2D,
    pub refreshRate: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplayModeProperties2KHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub displayModeProperties: VkDisplayModePropertiesKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplayModePropertiesKHR {
    pub displayMode: VkDisplayModeKHR,
    pub parameters: VkDisplayModeParametersKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplayModeStereoPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub hdmi3DSupported: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplayNativeHdrSurfaceCapabilitiesAMD {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub localDimmingSupport: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplayPlaneCapabilities2KHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub capabilities: VkDisplayPlaneCapabilitiesKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplayPlaneCapabilitiesKHR {
    pub supportedAlpha: VkDisplayPlaneAlphaFlagsKHR,
    pub minSrcPosition: VkOffset2D,
    pub maxSrcPosition: VkOffset2D,
    pub minSrcExtent: VkExtent2D,
    pub maxSrcExtent: VkExtent2D,
    pub minDstPosition: VkOffset2D,
    pub maxDstPosition: VkOffset2D,
    pub minDstExtent: VkExtent2D,
    pub maxDstExtent: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplayPlaneInfo2KHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub mode: VkDisplayModeKHR,
    pub planeIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplayPlaneProperties2KHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub displayPlaneProperties: VkDisplayPlanePropertiesKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplayPlanePropertiesKHR {
    pub currentDisplay: VkDisplayKHR,
    pub currentStackIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplayPowerInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub powerState: VkDisplayPowerStateEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplayPresentInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcRect: VkRect2D,
    pub dstRect: VkRect2D,
    pub persistent: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplayProperties2KHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub displayProperties: VkDisplayPropertiesKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplayPropertiesKHR {
    pub display: VkDisplayKHR,
    pub displayName: *const c_char,
    pub physicalDimensions: VkExtent2D,
    pub physicalResolution: VkExtent2D,
    pub supportedTransforms: VkSurfaceTransformFlagsKHR,
    pub planeReorderPossible: VkBool32,
    pub persistentContent: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplaySurfaceCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkDisplaySurfaceCreateFlagsKHR,
    pub displayMode: VkDisplayModeKHR,
    pub planeIndex: u32,
    pub planeStackIndex: u32,
    pub transform: VkSurfaceTransformFlagBitsKHR,
    pub globalAlpha: f32,
    pub alphaMode: VkDisplayPlaneAlphaFlagBitsKHR,
    pub imageExtent: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDisplaySurfaceStereoCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stereoType: VkDisplaySurfaceStereoTypeNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDrawIndexedIndirectCommand {
    pub indexCount: u32,
    pub instanceCount: u32,
    pub firstIndex: u32,
    pub vertexOffset: i32,
    pub firstInstance: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDrawIndirectCommand {
    pub vertexCount: u32,
    pub instanceCount: u32,
    pub firstVertex: u32,
    pub firstInstance: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDrawIndirectCountIndirectCommandEXT {
    pub bufferAddress: VkDeviceAddress,
    pub stride: u32,
    pub commandCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDrawMeshTasksIndirectCommandEXT {
    pub groupCountX: u32,
    pub groupCountY: u32,
    pub groupCountZ: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDrawMeshTasksIndirectCommandNV {
    pub taskCount: u32,
    pub firstTask: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDrmFormatModifierProperties2EXT {
    pub drmFormatModifier: u64,
    pub drmFormatModifierPlaneCount: u32,
    pub drmFormatModifierTilingFeatures: VkFormatFeatureFlags2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDrmFormatModifierPropertiesEXT {
    pub drmFormatModifier: u64,
    pub drmFormatModifierPlaneCount: u32,
    pub drmFormatModifierTilingFeatures: VkFormatFeatureFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDrmFormatModifierPropertiesList2EXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub drmFormatModifierCount: u32,
    pub pDrmFormatModifierProperties: *mut VkDrmFormatModifierProperties2EXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkDrmFormatModifierPropertiesListEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub drmFormatModifierCount: u32,
    pub pDrmFormatModifierProperties: *mut VkDrmFormatModifierPropertiesEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkEventCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkEventCreateFlags,
}

#[repr(C)]
pub struct VkEvent_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExportFenceCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub handleTypes: VkExternalFenceHandleTypeFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExportMemoryAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub handleTypes: VkExternalMemoryHandleTypeFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExportMemoryAllocateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub handleTypes: VkExternalMemoryHandleTypeFlagsNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExportSemaphoreCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub handleTypes: VkExternalSemaphoreHandleTypeFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExtensionProperties {
    pub extensionName: [c_char; VK_MAX_EXTENSION_NAME_SIZE as usize],
    pub specVersion: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExtent2D {
    pub width: u32,
    pub height: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExtent3D {
    pub width: u32,
    pub height: u32,
    pub depth: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExternalBufferProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub externalMemoryProperties: VkExternalMemoryProperties,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExternalComputeQueueCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub preferredQueue: VkQueue,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExternalComputeQueueDataParamsNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub deviceIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExternalComputeQueueDeviceCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub reservedExternalQueues: u32,
}

#[repr(C)]
pub struct VkExternalComputeQueueNV_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExternalFenceProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub exportFromImportedHandleTypes: VkExternalFenceHandleTypeFlags,
    pub compatibleHandleTypes: VkExternalFenceHandleTypeFlags,
    pub externalFenceFeatures: VkExternalFenceFeatureFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExternalImageFormatProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub externalMemoryProperties: VkExternalMemoryProperties,
}

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

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExternalMemoryAcquireUnmodifiedEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub acquireUnmodifiedMemory: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExternalMemoryBufferCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub handleTypes: VkExternalMemoryHandleTypeFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExternalMemoryImageCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub handleTypes: VkExternalMemoryHandleTypeFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExternalMemoryImageCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub handleTypes: VkExternalMemoryHandleTypeFlagsNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExternalMemoryProperties {
    pub externalMemoryFeatures: VkExternalMemoryFeatureFlags,
    pub exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlags,
    pub compatibleHandleTypes: VkExternalMemoryHandleTypeFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExternalMemoryTensorCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub handleTypes: VkExternalMemoryHandleTypeFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExternalSemaphoreProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub exportFromImportedHandleTypes: VkExternalSemaphoreHandleTypeFlags,
    pub compatibleHandleTypes: VkExternalSemaphoreHandleTypeFlags,
    pub externalSemaphoreFeatures: VkExternalSemaphoreFeatureFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkExternalTensorPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub externalMemoryProperties: VkExternalMemoryProperties,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkFenceCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkFenceCreateFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkFenceGetFdInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub fence: VkFence,
    pub handleType: VkExternalFenceHandleTypeFlagBits,
}

#[repr(C)]
pub struct VkFence_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkFilterCubicImageViewImageFormatPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub filterCubic: VkBool32,
    pub filterCubicMinmax: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkFormatProperties {
    pub linearTilingFeatures: VkFormatFeatureFlags,
    pub optimalTilingFeatures: VkFormatFeatureFlags,
    pub bufferFeatures: VkFormatFeatureFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkFormatProperties2 {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub formatProperties: VkFormatProperties,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkFormatProperties3 {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub linearTilingFeatures: VkFormatFeatureFlags2,
    pub optimalTilingFeatures: VkFormatFeatureFlags2,
    pub bufferFeatures: VkFormatFeatureFlags2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkFragmentShadingRateAttachmentInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pFragmentShadingRateAttachment: *const VkAttachmentReference2,
    pub shadingRateAttachmentTexelSize: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkFrameBoundaryEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkFrameBoundaryFlagsEXT,
    pub frameID: u64,
    pub imageCount: u32,
    pub pImages: *const VkImage,
    pub bufferCount: u32,
    pub pBuffers: *const VkBuffer,
    pub tagName: u64,
    pub tagSize: usize,
    pub pTag: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkFrameBoundaryTensorsARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub tensorCount: u32,
    pub pTensors: *const VkTensorARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkFramebufferAttachmentImageInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkImageCreateFlags,
    pub usage: VkImageUsageFlags,
    pub width: u32,
    pub height: u32,
    pub layerCount: u32,
    pub viewFormatCount: u32,
    pub pViewFormats: *const VkFormat,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkFramebufferAttachmentsCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub attachmentImageInfoCount: u32,
    pub pAttachmentImageInfos: *const VkFramebufferAttachmentImageInfo,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkFramebufferCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkFramebufferCreateFlags,
    pub renderPass: VkRenderPass,
    pub attachmentCount: u32,
    pub pAttachments: *const VkImageView,
    pub width: u32,
    pub height: u32,
    pub layers: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkFramebufferMixedSamplesCombinationNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub coverageReductionMode: VkCoverageReductionModeNV,
    pub rasterizationSamples: VkSampleCountFlagBits,
    pub depthStencilSamples: VkSampleCountFlags,
    pub colorSamples: VkSampleCountFlags,
}

#[repr(C)]
pub struct VkFramebuffer_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkGeneratedCommandsInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub shaderStages: VkShaderStageFlags,
    pub indirectExecutionSet: VkIndirectExecutionSetEXT,
    pub indirectCommandsLayout: VkIndirectCommandsLayoutEXT,
    pub indirectAddress: VkDeviceAddress,
    pub indirectAddressSize: VkDeviceSize,
    pub preprocessAddress: VkDeviceAddress,
    pub preprocessSize: VkDeviceSize,
    pub maxSequenceCount: u32,
    pub sequenceCountAddress: VkDeviceAddress,
    pub maxDrawCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkGeneratedCommandsInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pipelineBindPoint: VkPipelineBindPoint,
    pub pipeline: VkPipeline,
    pub indirectCommandsLayout: VkIndirectCommandsLayoutNV,
    pub streamCount: u32,
    pub pStreams: *const VkIndirectCommandsStreamNV,
    pub sequencesCount: u32,
    pub preprocessBuffer: VkBuffer,
    pub preprocessOffset: VkDeviceSize,
    pub preprocessSize: VkDeviceSize,
    pub sequencesCountBuffer: VkBuffer,
    pub sequencesCountOffset: VkDeviceSize,
    pub sequencesIndexBuffer: VkBuffer,
    pub sequencesIndexOffset: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkGeneratedCommandsMemoryRequirementsInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub indirectExecutionSet: VkIndirectExecutionSetEXT,
    pub indirectCommandsLayout: VkIndirectCommandsLayoutEXT,
    pub maxSequenceCount: u32,
    pub maxDrawCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkGeneratedCommandsMemoryRequirementsInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pipelineBindPoint: VkPipelineBindPoint,
    pub pipeline: VkPipeline,
    pub indirectCommandsLayout: VkIndirectCommandsLayoutNV,
    pub maxSequencesCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkGeneratedCommandsPipelineInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pipeline: VkPipeline,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkGeneratedCommandsShaderInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderCount: u32,
    pub pShaders: *const VkShaderEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkGeometryAABBNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub aabbData: VkBuffer,
    pub numAABBs: u32,
    pub stride: u32,
    pub offset: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkGeometryDataNV {
    pub triangles: VkGeometryTrianglesNV,
    pub aabbs: VkGeometryAABBNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkGeometryNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub geometryType: VkGeometryTypeKHR,
    pub geometry: VkGeometryDataNV,
    pub flags: VkGeometryFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkGeometryTrianglesNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub vertexData: VkBuffer,
    pub vertexOffset: VkDeviceSize,
    pub vertexCount: u32,
    pub vertexStride: VkDeviceSize,
    pub vertexFormat: VkFormat,
    pub indexData: VkBuffer,
    pub indexOffset: VkDeviceSize,
    pub indexCount: u32,
    pub indexType: VkIndexType,
    pub transformData: VkBuffer,
    pub transformOffset: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkGetLatencyMarkerInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub timingCount: u32,
    pub pTimings: *mut VkLatencyTimingsFrameReportNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkGraphicsPipelineCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineCreateFlags,
    pub stageCount: u32,
    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,
    pub layout: VkPipelineLayout,
    pub renderPass: VkRenderPass,
    pub subpass: u32,
    pub basePipelineHandle: VkPipeline,
    pub basePipelineIndex: i32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkGraphicsPipelineLibraryCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkGraphicsPipelineLibraryFlagsEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkGraphicsPipelineShaderGroupsCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub groupCount: u32,
    pub pGroups: *const VkGraphicsShaderGroupCreateInfoNV,
    pub pipelineCount: u32,
    pub pPipelines: *const VkPipeline,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkGraphicsShaderGroupCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stageCount: u32,
    pub pStages: *const VkPipelineShaderStageCreateInfo,
    pub pVertexInputState: *const VkPipelineVertexInputStateCreateInfo,
    pub pTessellationState: *const VkPipelineTessellationStateCreateInfo,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkHdrMetadataEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub displayPrimaryRed: VkXYColorEXT,
    pub displayPrimaryGreen: VkXYColorEXT,
    pub displayPrimaryBlue: VkXYColorEXT,
    pub whitePoint: VkXYColorEXT,
    pub maxLuminance: f32,
    pub minLuminance: f32,
    pub maxContentLightLevel: f32,
    pub maxFrameAverageLightLevel: f32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkHdrVividDynamicMetadataHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub dynamicMetadataSize: usize,
    pub pDynamicMetadata: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkHeadlessSurfaceCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkHeadlessSurfaceCreateFlagsEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkHostImageCopyDevicePerformanceQuery {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub optimalDeviceAccess: VkBool32,
    pub identicalMemoryLayout: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkHostImageLayoutTransitionInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub image: VkImage,
    pub oldLayout: VkImageLayout,
    pub newLayout: VkImageLayout,
    pub subresourceRange: VkImageSubresourceRange,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageAlignmentControlCreateInfoMESA {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub maximumRequestedAlignment: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageBlit {
    pub srcSubresource: VkImageSubresourceLayers,
    pub srcOffsets: [VkOffset3D; 2 as usize],
    pub dstSubresource: VkImageSubresourceLayers,
    pub dstOffsets: [VkOffset3D; 2 as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageBlit2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcSubresource: VkImageSubresourceLayers,
    pub srcOffsets: [VkOffset3D; 2 as usize],
    pub dstSubresource: VkImageSubresourceLayers,
    pub dstOffsets: [VkOffset3D; 2 as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageCaptureDescriptorDataInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub image: VkImage,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageCompressionControlEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkImageCompressionFlagsEXT,
    pub compressionControlPlaneCount: u32,
    pub pFixedRateFlags: *mut VkImageCompressionFixedRateFlagsEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageCompressionPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub imageCompressionFlags: VkImageCompressionFlagsEXT,
    pub imageCompressionFixedRateFlags: VkImageCompressionFixedRateFlagsEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageCopy {
    pub srcSubresource: VkImageSubresourceLayers,
    pub srcOffset: VkOffset3D,
    pub dstSubresource: VkImageSubresourceLayers,
    pub dstOffset: VkOffset3D,
    pub extent: VkExtent3D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageCopy2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcSubresource: VkImageSubresourceLayers,
    pub srcOffset: VkOffset3D,
    pub dstSubresource: VkImageSubresourceLayers,
    pub dstOffset: VkOffset3D,
    pub extent: VkExtent3D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkImageCreateFlags,
    pub imageType: VkImageType,
    pub format: VkFormat,
    pub extent: VkExtent3D,
    pub mipLevels: u32,
    pub arrayLayers: u32,
    pub samples: VkSampleCountFlagBits,
    pub tiling: VkImageTiling,
    pub usage: VkImageUsageFlags,
    pub sharingMode: VkSharingMode,
    pub queueFamilyIndexCount: u32,
    pub pQueueFamilyIndices: *const u32,
    pub initialLayout: VkImageLayout,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageDrmFormatModifierExplicitCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub drmFormatModifier: u64,
    pub drmFormatModifierPlaneCount: u32,
    pub pPlaneLayouts: *const VkSubresourceLayout,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageDrmFormatModifierListCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub drmFormatModifierCount: u32,
    pub pDrmFormatModifiers: *const u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageDrmFormatModifierPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub drmFormatModifier: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageFormatListCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub viewFormatCount: u32,
    pub pViewFormats: *const VkFormat,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageFormatProperties {
    pub maxExtent: VkExtent3D,
    pub maxMipLevels: u32,
    pub maxArrayLayers: u32,
    pub sampleCounts: VkSampleCountFlags,
    pub maxResourceSize: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageFormatProperties2 {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub imageFormatProperties: VkImageFormatProperties,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageMemoryBarrier {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcAccessMask: VkAccessFlags,
    pub dstAccessMask: VkAccessFlags,
    pub oldLayout: VkImageLayout,
    pub newLayout: VkImageLayout,
    pub srcQueueFamilyIndex: u32,
    pub dstQueueFamilyIndex: u32,
    pub image: VkImage,
    pub subresourceRange: VkImageSubresourceRange,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageMemoryBarrier2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcStageMask: VkPipelineStageFlags2,
    pub srcAccessMask: VkAccessFlags2,
    pub dstStageMask: VkPipelineStageFlags2,
    pub dstAccessMask: VkAccessFlags2,
    pub oldLayout: VkImageLayout,
    pub newLayout: VkImageLayout,
    pub srcQueueFamilyIndex: u32,
    pub dstQueueFamilyIndex: u32,
    pub image: VkImage,
    pub subresourceRange: VkImageSubresourceRange,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageMemoryRequirementsInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub image: VkImage,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImagePlaneMemoryRequirementsInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub planeAspect: VkImageAspectFlagBits,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageResolve {
    pub srcSubresource: VkImageSubresourceLayers,
    pub srcOffset: VkOffset3D,
    pub dstSubresource: VkImageSubresourceLayers,
    pub dstOffset: VkOffset3D,
    pub extent: VkExtent3D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageResolve2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcSubresource: VkImageSubresourceLayers,
    pub srcOffset: VkOffset3D,
    pub dstSubresource: VkImageSubresourceLayers,
    pub dstOffset: VkOffset3D,
    pub extent: VkExtent3D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageSparseMemoryRequirementsInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub image: VkImage,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageStencilUsageCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stencilUsage: VkImageUsageFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageSubresource {
    pub aspectMask: VkImageAspectFlags,
    pub mipLevel: u32,
    pub arrayLayer: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageSubresource2 {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub imageSubresource: VkImageSubresource,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageSubresourceLayers {
    pub aspectMask: VkImageAspectFlags,
    pub mipLevel: u32,
    pub baseArrayLayer: u32,
    pub layerCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageSubresourceRange {
    pub aspectMask: VkImageAspectFlags,
    pub baseMipLevel: u32,
    pub levelCount: u32,
    pub baseArrayLayer: u32,
    pub layerCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageSwapchainCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub swapchain: VkSwapchainKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageToMemoryCopy {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pHostPointer: *mut c_void,
    pub memoryRowLength: u32,
    pub memoryImageHeight: u32,
    pub imageSubresource: VkImageSubresourceLayers,
    pub imageOffset: VkOffset3D,
    pub imageExtent: VkExtent3D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageViewASTCDecodeModeEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub decodeMode: VkFormat,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageViewAddressPropertiesNVX {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub deviceAddress: VkDeviceAddress,
    pub size: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageViewCaptureDescriptorDataInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub imageView: VkImageView,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageViewCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkImageViewCreateFlags,
    pub image: VkImage,
    pub viewType: VkImageViewType,
    pub format: VkFormat,
    pub components: VkComponentMapping,
    pub subresourceRange: VkImageSubresourceRange,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageViewHandleInfoNVX {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub imageView: VkImageView,
    pub descriptorType: VkDescriptorType,
    pub sampler: VkSampler,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageViewMinLodCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub minLod: f32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageViewSampleWeightCreateInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub filterCenter: VkOffset2D,
    pub filterSize: VkExtent2D,
    pub numPhases: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageViewSlicedCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub sliceOffset: u32,
    pub sliceCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImageViewUsageCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub usage: VkImageUsageFlags,
}

#[repr(C)]
pub struct VkImageView_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[repr(C)]
pub struct VkImage_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImportFenceFdInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub fence: VkFence,
    pub flags: VkFenceImportFlags,
    pub handleType: VkExternalFenceHandleTypeFlagBits,
    pub fd: c_int,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImportMemoryFdInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub handleType: VkExternalMemoryHandleTypeFlagBits,
    pub fd: c_int,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImportMemoryHostPointerInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub handleType: VkExternalMemoryHandleTypeFlagBits,
    pub pHostPointer: *mut c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkImportSemaphoreFdInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub semaphore: VkSemaphore,
    pub flags: VkSemaphoreImportFlags,
    pub handleType: VkExternalSemaphoreHandleTypeFlagBits,
    pub fd: c_int,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkIndirectCommandsExecutionSetTokenEXT {
    pub typ: VkIndirectExecutionSetInfoTypeEXT,
    pub shaderStages: VkShaderStageFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkIndirectCommandsIndexBufferTokenEXT {
    pub mode: VkIndirectCommandsInputModeFlagBitsEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkIndirectCommandsLayoutCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkIndirectCommandsLayoutUsageFlagsEXT,
    pub shaderStages: VkShaderStageFlags,
    pub indirectStride: u32,
    pub pipelineLayout: VkPipelineLayout,
    pub tokenCount: u32,
    pub pTokens: *const VkIndirectCommandsLayoutTokenEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkIndirectCommandsLayoutCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkIndirectCommandsLayoutUsageFlagsNV,
    pub pipelineBindPoint: VkPipelineBindPoint,
    pub tokenCount: u32,
    pub pTokens: *const VkIndirectCommandsLayoutTokenNV,
    pub streamCount: u32,
    pub pStreamStrides: *const u32,
}

#[repr(C)]
pub struct VkIndirectCommandsLayoutEXT_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[repr(C)]
pub struct VkIndirectCommandsLayoutNV_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkIndirectCommandsLayoutTokenEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub typ: VkIndirectCommandsTokenTypeEXT,
    pub data: VkIndirectCommandsTokenDataEXT,
    pub offset: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkIndirectCommandsLayoutTokenNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub tokenType: VkIndirectCommandsTokenTypeNV,
    pub stream: u32,
    pub offset: u32,
    pub vertexBindingUnit: u32,
    pub vertexDynamicStride: VkBool32,
    pub pushconstantPipelineLayout: VkPipelineLayout,
    pub pushconstantShaderStageFlags: VkShaderStageFlags,
    pub pushconstantOffset: u32,
    pub pushconstantSize: u32,
    pub indirectStateFlags: VkIndirectStateFlagsNV,
    pub indexTypeCount: u32,
    pub pIndexTypes: *const VkIndexType,
    pub pIndexTypeValues: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkIndirectCommandsPushConstantTokenEXT {
    pub updateRange: VkPushConstantRange,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkIndirectCommandsStreamNV {
    pub buffer: VkBuffer,
    pub offset: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkIndirectCommandsVertexBufferTokenEXT {
    pub vertexBindingUnit: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkIndirectExecutionSetCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub typ: VkIndirectExecutionSetInfoTypeEXT,
    pub info: VkIndirectExecutionSetInfoEXT,
}

#[repr(C)]
pub struct VkIndirectExecutionSetEXT_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkIndirectExecutionSetPipelineInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub initialPipeline: VkPipeline,
    pub maxPipelineCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkIndirectExecutionSetShaderInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub shaderCount: u32,
    pub pInitialShaders: *const VkShaderEXT,
    pub pSetLayoutInfos: *const VkIndirectExecutionSetShaderLayoutInfoEXT,
    pub maxShaderCount: u32,
    pub pushConstantRangeCount: u32,
    pub pPushConstantRanges: *const VkPushConstantRange,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkIndirectExecutionSetShaderLayoutInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub setLayoutCount: u32,
    pub pSetLayouts: *const VkDescriptorSetLayout,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkInitializePerformanceApiInfoINTEL {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pUserData: *mut c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkInputAttachmentAspectReference {
    pub subpass: u32,
    pub inputAttachmentIndex: u32,
    pub aspectMask: VkImageAspectFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkInstanceCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkInstanceCreateFlags,
    pub pApplicationInfo: *const VkApplicationInfo,
    pub enabledLayerCount: u32,
    pub ppEnabledLayerNames: *const *const c_char,
    pub enabledExtensionCount: u32,
    pub ppEnabledExtensionNames: *const *const c_char,
}

#[repr(C)]
pub struct VkInstance_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkLatencySleepInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub signalSemaphore: VkSemaphore,
    pub value: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkLatencySleepModeInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub lowLatencyMode: VkBool32,
    pub lowLatencyBoost: VkBool32,
    pub minimumIntervalUs: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkLatencySubmissionPresentIdNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub presentID: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkLatencySurfaceCapabilitiesNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub presentModeCount: u32,
    pub pPresentModes: *mut VkPresentModeKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkLatencyTimingsFrameReportNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentID: u64,
    pub inputSampleTimeUs: u64,
    pub simStartTimeUs: u64,
    pub simEndTimeUs: u64,
    pub renderSubmitStartTimeUs: u64,
    pub renderSubmitEndTimeUs: u64,
    pub presentStartTimeUs: u64,
    pub presentEndTimeUs: u64,
    pub driverStartTimeUs: u64,
    pub driverEndTimeUs: u64,
    pub osRenderQueueStartTimeUs: u64,
    pub osRenderQueueEndTimeUs: u64,
    pub gpuRenderStartTimeUs: u64,
    pub gpuRenderEndTimeUs: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkLayerProperties {
    pub layerName: [c_char; VK_MAX_EXTENSION_NAME_SIZE as usize],
    pub specVersion: u32,
    pub implementationVersion: u32,
    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkLayerSettingEXT {
    pub pLayerName: *const c_char,
    pub pSettingName: *const c_char,
    pub typ: VkLayerSettingTypeEXT,
    pub valueCount: u32,
    pub pValues: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkLayerSettingsCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub settingCount: u32,
    pub pSettings: *const VkLayerSettingEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMappedMemoryRange {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub memory: VkDeviceMemory,
    pub offset: VkDeviceSize,
    pub size: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryAllocateFlagsInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkMemoryAllocateFlags,
    pub deviceMask: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub allocationSize: VkDeviceSize,
    pub memoryTypeIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryBarrier {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcAccessMask: VkAccessFlags,
    pub dstAccessMask: VkAccessFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryBarrier2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcStageMask: VkPipelineStageFlags2,
    pub srcAccessMask: VkAccessFlags2,
    pub dstStageMask: VkPipelineStageFlags2,
    pub dstAccessMask: VkAccessFlags2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryBarrierAccessFlags3KHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcAccessMask3: VkAccessFlags3KHR,
    pub dstAccessMask3: VkAccessFlags3KHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryDedicatedAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub image: VkImage,
    pub buffer: VkBuffer,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryDedicatedAllocateInfoTensorARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub tensor: VkTensorARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryDedicatedRequirements {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub prefersDedicatedAllocation: VkBool32,
    pub requiresDedicatedAllocation: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryFdPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub memoryTypeBits: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryGetFdInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub memory: VkDeviceMemory,
    pub handleType: VkExternalMemoryHandleTypeFlagBits,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryGetRemoteAddressInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub memory: VkDeviceMemory,
    pub handleType: VkExternalMemoryHandleTypeFlagBits,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryHeap {
    pub size: VkDeviceSize,
    pub flags: VkMemoryHeapFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryHostPointerPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub memoryTypeBits: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryMapInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkMemoryMapFlags,
    pub memory: VkDeviceMemory,
    pub offset: VkDeviceSize,
    pub size: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryMapPlacedInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pPlacedAddress: *mut c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryOpaqueCaptureAddressAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub opaqueCaptureAddress: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryPriorityAllocateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub priority: f32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryRequirements {
    pub size: VkDeviceSize,
    pub alignment: VkDeviceSize,
    pub memoryTypeBits: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryRequirements2 {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub memoryRequirements: VkMemoryRequirements,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryToImageCopy {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pHostPointer: *const c_void,
    pub memoryRowLength: u32,
    pub memoryImageHeight: u32,
    pub imageSubresource: VkImageSubresourceLayers,
    pub imageOffset: VkOffset3D,
    pub imageExtent: VkExtent3D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryType {
    pub propertyFlags: VkMemoryPropertyFlags,
    pub heapIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMemoryUnmapInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkMemoryUnmapFlags,
    pub memory: VkDeviceMemory,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMicromapBuildInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub typ: VkMicromapTypeEXT,
    pub flags: VkBuildMicromapFlagsEXT,
    pub mode: VkBuildMicromapModeEXT,
    pub dstMicromap: VkMicromapEXT,
    pub usageCountsCount: u32,
    pub pUsageCounts: *const VkMicromapUsageEXT,
    pub ppUsageCounts: *const *const VkMicromapUsageEXT,
    pub data: VkDeviceOrHostAddressConstKHR,
    pub scratchData: VkDeviceOrHostAddressKHR,
    pub triangleArray: VkDeviceOrHostAddressConstKHR,
    pub triangleArrayStride: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMicromapBuildSizesInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub micromapSize: VkDeviceSize,
    pub buildScratchSize: VkDeviceSize,
    pub discardable: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMicromapCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub createFlags: VkMicromapCreateFlagsEXT,
    pub buffer: VkBuffer,
    pub offset: VkDeviceSize,
    pub size: VkDeviceSize,
    pub typ: VkMicromapTypeEXT,
    pub deviceAddress: VkDeviceAddress,
}

#[repr(C)]
pub struct VkMicromapEXT_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMicromapTriangleEXT {
    pub dataOffset: u32,
    pub subdivisionLevel: u16,
    pub format: u16,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMicromapUsageEXT {
    pub count: u32,
    pub subdivisionLevel: u32,
    pub format: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMicromapVersionInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pVersionData: *const u8,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMultiDrawIndexedInfoEXT {
    pub firstIndex: u32,
    pub indexCount: u32,
    pub vertexOffset: i32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMultiDrawInfoEXT {
    pub firstVertex: u32,
    pub vertexCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMultisamplePropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxSampleLocationGridSize: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMultisampledRenderToSingleSampledInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub multisampledRenderToSingleSampledEnable: VkBool32,
    pub rasterizationSamples: VkSampleCountFlagBits,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMultiviewPerViewAttributesInfoNVX {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub perViewAttributes: VkBool32,
    pub perViewAttributesPositionXOnly: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub perViewRenderAreaCount: u32,
    pub pPerViewRenderAreas: *const VkRect2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMutableDescriptorTypeCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub mutableDescriptorTypeListCount: u32,
    pub pMutableDescriptorTypeLists: *const VkMutableDescriptorTypeListEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkMutableDescriptorTypeListEXT {
    pub descriptorTypeCount: u32,
    pub pDescriptorTypes: *const VkDescriptorType,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkOffset2D {
    pub x: i32,
    pub y: i32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkOffset3D {
    pub x: i32,
    pub y: i32,
    pub z: i32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkOpaqueCaptureDescriptorDataCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub opaqueCaptureDescriptorData: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkOpticalFlowExecuteInfoNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub flags: VkOpticalFlowExecuteFlagsNV,
    pub regionCount: u32,
    pub pRegions: *const VkRect2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkOpticalFlowImageFormatInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub usage: VkOpticalFlowUsageFlagsNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkOpticalFlowImageFormatPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub format: VkFormat,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkOpticalFlowSessionCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub width: u32,
    pub height: u32,
    pub imageFormat: VkFormat,
    pub flowVectorFormat: VkFormat,
    pub costFormat: VkFormat,
    pub outputGridSize: VkOpticalFlowGridSizeFlagsNV,
    pub hintGridSize: VkOpticalFlowGridSizeFlagsNV,
    pub performanceLevel: VkOpticalFlowPerformanceLevelNV,
    pub flags: VkOpticalFlowSessionCreateFlagsNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkOpticalFlowSessionCreatePrivateDataInfoNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub id: u32,
    pub size: u32,
    pub pPrivateData: *const c_void,
}

#[repr(C)]
pub struct VkOpticalFlowSessionNV_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkOutOfBandQueueTypeInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub queueType: VkOutOfBandQueueTypeNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPartitionedAccelerationStructureFlagsNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub enablePartitionTranslation: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPartitionedAccelerationStructureInstancesInputNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub flags: VkBuildAccelerationStructureFlagsKHR,
    pub instanceCount: u32,
    pub maxInstancePerPartitionCount: u32,
    pub partitionCount: u32,
    pub maxInstanceInGlobalPartitionCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPartitionedAccelerationStructureUpdateInstanceDataNV {
    pub instanceIndex: u32,
    pub instanceContributionToHitGroupIndex: u32,
    pub accelerationStructure: VkDeviceAddress,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPartitionedAccelerationStructureWriteInstanceDataNV {
    pub transform: VkTransformMatrixKHR,
    pub explicitAABB: [f32; 6 as usize],
    pub instanceID: u32,
    pub instanceMask: u32,
    pub instanceContributionToHitGroupIndex: u32,
    pub instanceFlags: VkPartitionedAccelerationStructureInstanceFlagsNV,
    pub instanceIndex: u32,
    pub partitionIndex: u32,
    pub accelerationStructure: VkDeviceAddress,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPartitionedAccelerationStructureWritePartitionTranslationDataNV {
    pub partitionIndex: u32,
    pub partitionTranslation: [f32; 3 as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPastPresentationTimingEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentId: u64,
    pub targetTime: u64,
    pub presentStageCount: u32,
    pub pPresentStages: *mut VkPresentStageTimeEXT,
    pub timeDomain: VkTimeDomainKHR,
    pub timeDomainId: u64,
    pub reportComplete: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPastPresentationTimingGOOGLE {
    pub presentID: u32,
    pub desiredPresentTime: u64,
    pub actualPresentTime: u64,
    pub earliestPresentTime: u64,
    pub presentMargin: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPastPresentationTimingInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPastPresentationTimingFlagsEXT,
    pub swapchain: VkSwapchainKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPastPresentationTimingPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub timingPropertiesCounter: u64,
    pub timeDomainsCounter: u64,
    pub presentationTimingCount: u32,
    pub pPresentationTimings: *mut VkPastPresentationTimingEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPerTileBeginInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPerTileEndInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPerformanceConfigurationAcquireInfoINTEL {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub typ: VkPerformanceConfigurationTypeINTEL,
}

#[repr(C)]
pub struct VkPerformanceConfigurationINTEL_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPerformanceCounterARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub counterID: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPerformanceCounterDescriptionARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub flags: VkPerformanceCounterDescriptionFlagsARM,
    pub name: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPerformanceCounterDescriptionKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_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],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPerformanceCounterKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub unit: VkPerformanceCounterUnitKHR,
    pub scope: VkPerformanceCounterScopeKHR,
    pub storage: VkPerformanceCounterStorageKHR,
    pub uuid: [u8; VK_UUID_SIZE as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPerformanceMarkerInfoINTEL {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub marker: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPerformanceOverrideInfoINTEL {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub typ: VkPerformanceOverrideTypeINTEL,
    pub enable: VkBool32,
    pub parameter: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPerformanceQuerySubmitInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub counterPassIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPerformanceStreamMarkerInfoINTEL {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub marker: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPerformanceValueINTEL {
    pub typ: VkPerformanceValueTypeINTEL,
    pub data: VkPerformanceValueDataINTEL,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevice16BitStorageFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub storageBuffer16BitAccess: VkBool32,
    pub uniformAndStorageBuffer16BitAccess: VkBool32,
    pub storagePushConstant16: VkBool32,
    pub storageInputOutput16: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevice4444FormatsFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub formatA4R4G4B4: VkBool32,
    pub formatA4B4G4R4: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevice8BitStorageFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub storageBuffer8BitAccess: VkBool32,
    pub uniformAndStorageBuffer8BitAccess: VkBool32,
    pub storagePushConstant8: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceASTCDecodeFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub decodeModeSharedExponent: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceAccelerationStructureFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub accelerationStructure: VkBool32,
    pub accelerationStructureCaptureReplay: VkBool32,
    pub accelerationStructureIndirectBuild: VkBool32,
    pub accelerationStructureHostCommands: VkBool32,
    pub descriptorBindingAccelerationStructureUpdateAfterBind: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceAccelerationStructurePropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxGeometryCount: u64,
    pub maxInstanceCount: u64,
    pub maxPrimitiveCount: u64,
    pub maxPerStageDescriptorAccelerationStructures: u32,
    pub maxPerStageDescriptorUpdateAfterBindAccelerationStructures: u32,
    pub maxDescriptorSetAccelerationStructures: u32,
    pub maxDescriptorSetUpdateAfterBindAccelerationStructures: u32,
    pub minAccelerationStructureScratchOffsetAlignment: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceAddressBindingReportFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub reportAddressBinding: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceAmigoProfilingFeaturesSEC {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub amigoProfiling: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceAntiLagFeaturesAMD {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub antiLag: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub attachmentFeedbackLoopDynamicState: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub attachmentFeedbackLoopLayout: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub advancedBlendCoherentOperations: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub advancedBlendMaxColorAttachments: u32,
    pub advancedBlendIndependentBlend: VkBool32,
    pub advancedBlendNonPremultipliedSrcColor: VkBool32,
    pub advancedBlendNonPremultipliedDstColor: VkBool32,
    pub advancedBlendCorrelatedOverlap: VkBool32,
    pub advancedBlendAllOperations: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub borderColorSwizzle: VkBool32,
    pub borderColorSwizzleFromImage: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceBufferDeviceAddressFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub bufferDeviceAddress: VkBool32,
    pub bufferDeviceAddressCaptureReplay: VkBool32,
    pub bufferDeviceAddressMultiDevice: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub bufferDeviceAddress: VkBool32,
    pub bufferDeviceAddressCaptureReplay: VkBool32,
    pub bufferDeviceAddressMultiDevice: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceClusterAccelerationStructureFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub clusterAccelerationStructure: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceClusterAccelerationStructurePropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxVerticesPerCluster: u32,
    pub maxTrianglesPerCluster: u32,
    pub clusterScratchByteAlignment: u32,
    pub clusterByteAlignment: u32,
    pub clusterTemplateByteAlignment: u32,
    pub clusterBottomLevelByteAlignment: u32,
    pub clusterTemplateBoundsByteAlignment: u32,
    pub maxClusterGeometryIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub clustercullingShader: VkBool32,
    pub multiviewClusterCullingShader: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxWorkGroupCount: [u32; 3 as usize],
    pub maxWorkGroupSize: [u32; 3 as usize],
    pub maxOutputClusterCount: u32,
    pub indirectBufferOffsetAlignment: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub clusterShadingRate: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCoherentMemoryFeaturesAMD {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub deviceCoherentMemory: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceColorWriteEnableFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub colorWriteEnable: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCommandBufferInheritanceFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub commandBufferInheritance: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub computeOccupancyPriority: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub computeDerivativeGroupQuads: VkBool32,
    pub computeDerivativeGroupLinear: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub meshAndTaskShaderDerivatives: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceConditionalRenderingFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub conditionalRendering: VkBool32,
    pub inheritedConditionalRendering: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub primitiveOverestimationSize: f32,
    pub maxExtraPrimitiveOverestimationSize: f32,
    pub extraPrimitiveOverestimationSizeGranularity: f32,
    pub primitiveUnderestimation: VkBool32,
    pub conservativePointAndLineRasterization: VkBool32,
    pub degenerateTrianglesRasterized: VkBool32,
    pub degenerateLinesRasterized: VkBool32,
    pub fullyCoveredFragmentShaderInputVariable: VkBool32,
    pub conservativeRasterizationPostDepthCoverage: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCooperativeMatrix2FeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub cooperativeMatrixWorkgroupScope: VkBool32,
    pub cooperativeMatrixFlexibleDimensions: VkBool32,
    pub cooperativeMatrixReductions: VkBool32,
    pub cooperativeMatrixConversions: VkBool32,
    pub cooperativeMatrixPerElementOperations: VkBool32,
    pub cooperativeMatrixTensorAddressing: VkBool32,
    pub cooperativeMatrixBlockLoads: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCooperativeMatrix2PropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub cooperativeMatrixWorkgroupScopeMaxWorkgroupSize: u32,
    pub cooperativeMatrixFlexibleDimensionsMaxDimension: u32,
    pub cooperativeMatrixWorkgroupScopeReservedSharedMemory: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub cooperativeMatrix: VkBool32,
    pub cooperativeMatrixRobustBufferAccess: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCooperativeMatrixFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub cooperativeMatrix: VkBool32,
    pub cooperativeMatrixRobustBufferAccess: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub cooperativeMatrixSupportedStages: VkShaderStageFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCooperativeMatrixPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub cooperativeMatrixSupportedStages: VkShaderStageFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCooperativeVectorFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub cooperativeVector: VkBool32,
    pub cooperativeVectorTraining: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCooperativeVectorPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub cooperativeVectorSupportedStages: VkShaderStageFlags,
    pub cooperativeVectorTrainingFloat16Accumulation: VkBool32,
    pub cooperativeVectorTrainingFloat32Accumulation: VkBool32,
    pub maxCooperativeVectorComponents: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub indirectMemoryCopy: VkBool32,
    pub indirectMemoryToImageCopy: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub indirectCopy: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub supportedQueues: VkQueueFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCornerSampledImageFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub cornerSampledImage: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCoverageReductionModeFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub coverageReductionMode: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCubicClampFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub cubicRangeClamp: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCubicWeightsFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub selectableCubicWeights: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCustomBorderColorFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub customBorderColors: VkBool32,
    pub customBorderColorWithoutFormat: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCustomBorderColorPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxCustomBorderColorSamplers: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceCustomResolveFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub customResolve: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDataGraphFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub dataGraph: VkBool32,
    pub dataGraphUpdateAfterBind: VkBool32,
    pub dataGraphSpecializationConstants: VkBool32,
    pub dataGraphDescriptorBuffer: VkBool32,
    pub dataGraphShaderModule: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDataGraphModelFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub dataGraphModel: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
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: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDataGraphProcessingEngineARM {
    pub typ: VkPhysicalDeviceDataGraphProcessingEngineTypeARM,
    pub isForeign: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub dedicatedAllocationImageAliasing: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDepthBiasControlFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub depthBiasControl: VkBool32,
    pub leastRepresentableValueForceUnormRepresentation: VkBool32,
    pub floatRepresentation: VkBool32,
    pub depthBiasExact: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDepthClampControlFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub depthClampControl: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDepthClampZeroOneFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub depthClampZeroOne: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDepthClipControlFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub depthClipControl: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDepthClipEnableFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub depthClipEnable: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDepthStencilResolveProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub supportedDepthResolveModes: VkResolveModeFlags,
    pub supportedStencilResolveModes: VkResolveModeFlags,
    pub independentResolveNone: VkBool32,
    pub independentResolve: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub combinedImageSamplerDensityMapDescriptorSize: usize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDescriptorBufferFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub descriptorBuffer: VkBool32,
    pub descriptorBufferCaptureReplay: VkBool32,
    pub descriptorBufferImageLayoutIgnored: VkBool32,
    pub descriptorBufferPushDescriptors: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDescriptorBufferPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub combinedImageSamplerDescriptorSingleArray: VkBool32,
    pub bufferlessPushDescriptors: VkBool32,
    pub allowSamplerImageViewPostSubmitCreation: VkBool32,
    pub descriptorBufferOffsetAlignment: VkDeviceSize,
    pub maxDescriptorBufferBindings: u32,
    pub maxResourceDescriptorBufferBindings: u32,
    pub maxSamplerDescriptorBufferBindings: u32,
    pub maxEmbeddedImmutableSamplerBindings: u32,
    pub maxEmbeddedImmutableSamplers: u32,
    pub bufferCaptureReplayDescriptorDataSize: usize,
    pub imageCaptureReplayDescriptorDataSize: usize,
    pub imageViewCaptureReplayDescriptorDataSize: usize,
    pub samplerCaptureReplayDescriptorDataSize: usize,
    pub accelerationStructureCaptureReplayDescriptorDataSize: usize,
    pub samplerDescriptorSize: usize,
    pub combinedImageSamplerDescriptorSize: usize,
    pub sampledImageDescriptorSize: usize,
    pub storageImageDescriptorSize: usize,
    pub uniformTexelBufferDescriptorSize: usize,
    pub robustUniformTexelBufferDescriptorSize: usize,
    pub storageTexelBufferDescriptorSize: usize,
    pub robustStorageTexelBufferDescriptorSize: usize,
    pub uniformBufferDescriptorSize: usize,
    pub robustUniformBufferDescriptorSize: usize,
    pub storageBufferDescriptorSize: usize,
    pub robustStorageBufferDescriptorSize: usize,
    pub inputAttachmentDescriptorSize: usize,
    pub accelerationStructureDescriptorSize: usize,
    pub maxSamplerDescriptorBufferRange: VkDeviceSize,
    pub maxResourceDescriptorBufferRange: VkDeviceSize,
    pub samplerDescriptorBufferAddressSpaceSize: VkDeviceSize,
    pub resourceDescriptorBufferAddressSpaceSize: VkDeviceSize,
    pub descriptorBufferAddressSpaceSize: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub descriptorBufferTensorDescriptors: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub tensorCaptureReplayDescriptorDataSize: usize,
    pub tensorViewCaptureReplayDescriptorDataSize: usize,
    pub tensorDescriptorSize: usize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDescriptorIndexingFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDescriptorIndexingProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxUpdateAfterBindDescriptorsInAllPools: u32,
    pub shaderUniformBufferArrayNonUniformIndexingNative: VkBool32,
    pub shaderSampledImageArrayNonUniformIndexingNative: VkBool32,
    pub shaderStorageBufferArrayNonUniformIndexingNative: VkBool32,
    pub shaderStorageImageArrayNonUniformIndexingNative: VkBool32,
    pub shaderInputAttachmentArrayNonUniformIndexingNative: VkBool32,
    pub robustBufferAccessUpdateAfterBind: VkBool32,
    pub quadDivergentImplicitLod: VkBool32,
    pub maxPerStageDescriptorUpdateAfterBindSamplers: u32,
    pub maxPerStageDescriptorUpdateAfterBindUniformBuffers: u32,
    pub maxPerStageDescriptorUpdateAfterBindStorageBuffers: u32,
    pub maxPerStageDescriptorUpdateAfterBindSampledImages: u32,
    pub maxPerStageDescriptorUpdateAfterBindStorageImages: u32,
    pub maxPerStageDescriptorUpdateAfterBindInputAttachments: u32,
    pub maxPerStageUpdateAfterBindResources: u32,
    pub maxDescriptorSetUpdateAfterBindSamplers: u32,
    pub maxDescriptorSetUpdateAfterBindUniformBuffers: u32,
    pub maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: u32,
    pub maxDescriptorSetUpdateAfterBindStorageBuffers: u32,
    pub maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: u32,
    pub maxDescriptorSetUpdateAfterBindSampledImages: u32,
    pub maxDescriptorSetUpdateAfterBindStorageImages: u32,
    pub maxDescriptorSetUpdateAfterBindInputAttachments: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub descriptorPoolOverallocation: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub descriptorSetHostMapping: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub deviceGeneratedCompute: VkBool32,
    pub deviceGeneratedComputePipelines: VkBool32,
    pub deviceGeneratedComputeCaptureReplay: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub deviceGeneratedCommands: VkBool32,
    pub dynamicGeneratedPipelineLayout: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub deviceGeneratedCommands: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxIndirectPipelineCount: u32,
    pub maxIndirectShaderObjectCount: u32,
    pub maxIndirectSequenceCount: u32,
    pub maxIndirectCommandsTokenCount: u32,
    pub maxIndirectCommandsTokenOffset: u32,
    pub maxIndirectCommandsIndirectStride: u32,
    pub supportedIndirectCommandsInputModes: VkIndirectCommandsInputModeFlagsEXT,
    pub supportedIndirectCommandsShaderStages: VkShaderStageFlags,
    pub supportedIndirectCommandsShaderStagesPipelineBinding: VkShaderStageFlags,
    pub supportedIndirectCommandsShaderStagesShaderBinding: VkShaderStageFlags,
    pub deviceGeneratedCommandsTransformFeedback: VkBool32,
    pub deviceGeneratedCommandsMultiDrawIndirectCount: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxGraphicsShaderGroupCount: u32,
    pub maxIndirectSequenceCount: u32,
    pub maxIndirectCommandsTokenCount: u32,
    pub maxIndirectCommandsStreamCount: u32,
    pub maxIndirectCommandsTokenOffset: u32,
    pub maxIndirectCommandsStreamStride: u32,
    pub minSequencesCountBufferOffsetAlignment: u32,
    pub minSequencesIndexBufferOffsetAlignment: u32,
    pub minIndirectCommandsBufferOffsetAlignment: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub deviceMemoryReport: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub diagnosticsConfig: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxDiscardRectangles: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDriverProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDrmPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub hasPrimary: VkBool32,
    pub hasRender: VkBool32,
    pub primaryMajor: i64,
    pub primaryMinor: i64,
    pub renderMajor: i64,
    pub renderMinor: i64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDynamicRenderingFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub dynamicRendering: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDynamicRenderingLocalReadFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub dynamicRenderingLocalRead: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub dynamicRenderingUnusedAttachments: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceExclusiveScissorFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub exclusiveScissor: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub extendedDynamicState2: VkBool32,
    pub extendedDynamicState2LogicOp: VkBool32,
    pub extendedDynamicState2PatchControlPoints: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub dynamicPrimitiveTopologyUnrestricted: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub extendedDynamicState: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub extendedSparseAddressSpace: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub extendedSparseAddressSpaceSize: VkDeviceSize,
    pub extendedSparseImageUsageFlags: VkImageUsageFlags,
    pub extendedSparseBufferUsageFlags: VkBufferUsageFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceExternalBufferInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkBufferCreateFlags,
    pub usage: VkBufferUsageFlags,
    pub handleType: VkExternalMemoryHandleTypeFlagBits,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceExternalComputeQueuePropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub externalDataSize: u32,
    pub maxExternalQueues: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceExternalFenceInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub handleType: VkExternalFenceHandleTypeFlagBits,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceExternalImageFormatInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub handleType: VkExternalMemoryHandleTypeFlagBits,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub minImportedHostPointerAlignment: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub externalMemoryRDMA: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceExternalSemaphoreInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub handleType: VkExternalSemaphoreHandleTypeFlagBits,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceExternalTensorInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkTensorCreateFlagsARM,
    pub pDescription: *const VkTensorDescriptionARM,
    pub handleType: VkExternalMemoryHandleTypeFlagBits,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFaultFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub deviceFault: VkBool32,
    pub deviceFaultVendorBinary: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFeatures {
    pub robustBufferAccess: VkBool32,
    pub fullDrawIndexUint32: VkBool32,
    pub imageCubeArray: VkBool32,
    pub independentBlend: VkBool32,
    pub geometryShader: VkBool32,
    pub tessellationShader: VkBool32,
    pub sampleRateShading: VkBool32,
    pub dualSrcBlend: VkBool32,
    pub logicOp: VkBool32,
    pub multiDrawIndirect: VkBool32,
    pub drawIndirectFirstInstance: VkBool32,
    pub depthClamp: VkBool32,
    pub depthBiasClamp: VkBool32,
    pub fillModeNonSolid: VkBool32,
    pub depthBounds: VkBool32,
    pub wideLines: VkBool32,
    pub largePoints: VkBool32,
    pub alphaToOne: VkBool32,
    pub multiViewport: VkBool32,
    pub samplerAnisotropy: VkBool32,
    pub textureCompressionETC2: VkBool32,
    pub textureCompressionASTC_LDR: VkBool32,
    pub textureCompressionBC: VkBool32,
    pub occlusionQueryPrecise: VkBool32,
    pub pipelineStatisticsQuery: VkBool32,
    pub vertexPipelineStoresAndAtomics: VkBool32,
    pub fragmentStoresAndAtomics: VkBool32,
    pub shaderTessellationAndGeometryPointSize: VkBool32,
    pub shaderImageGatherExtended: VkBool32,
    pub shaderStorageImageExtendedFormats: VkBool32,
    pub shaderStorageImageMultisample: VkBool32,
    pub shaderStorageImageReadWithoutFormat: VkBool32,
    pub shaderStorageImageWriteWithoutFormat: VkBool32,
    pub shaderUniformBufferArrayDynamicIndexing: VkBool32,
    pub shaderSampledImageArrayDynamicIndexing: VkBool32,
    pub shaderStorageBufferArrayDynamicIndexing: VkBool32,
    pub shaderStorageImageArrayDynamicIndexing: VkBool32,
    pub shaderClipDistance: VkBool32,
    pub shaderCullDistance: VkBool32,
    pub shaderFloat64: VkBool32,
    pub shaderInt64: VkBool32,
    pub shaderInt16: VkBool32,
    pub shaderResourceResidency: VkBool32,
    pub shaderResourceMinLod: VkBool32,
    pub sparseBinding: VkBool32,
    pub sparseResidencyBuffer: VkBool32,
    pub sparseResidencyImage2D: VkBool32,
    pub sparseResidencyImage3D: VkBool32,
    pub sparseResidency2Samples: VkBool32,
    pub sparseResidency4Samples: VkBool32,
    pub sparseResidency8Samples: VkBool32,
    pub sparseResidency16Samples: VkBool32,
    pub sparseResidencyAliased: VkBool32,
    pub variableMultisampleRate: VkBool32,
    pub inheritedQueries: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFeatures2 {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub features: VkPhysicalDeviceFeatures,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFloatControlsProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub denormBehaviorIndependence: VkShaderFloatControlsIndependence,
    pub roundingModeIndependence: VkShaderFloatControlsIndependence,
    pub shaderSignedZeroInfNanPreserveFloat16: VkBool32,
    pub shaderSignedZeroInfNanPreserveFloat32: VkBool32,
    pub shaderSignedZeroInfNanPreserveFloat64: VkBool32,
    pub shaderDenormPreserveFloat16: VkBool32,
    pub shaderDenormPreserveFloat32: VkBool32,
    pub shaderDenormPreserveFloat64: VkBool32,
    pub shaderDenormFlushToZeroFloat16: VkBool32,
    pub shaderDenormFlushToZeroFloat32: VkBool32,
    pub shaderDenormFlushToZeroFloat64: VkBool32,
    pub shaderRoundingModeRTEFloat16: VkBool32,
    pub shaderRoundingModeRTEFloat32: VkBool32,
    pub shaderRoundingModeRTEFloat64: VkBool32,
    pub shaderRoundingModeRTZFloat16: VkBool32,
    pub shaderRoundingModeRTZFloat32: VkBool32,
    pub shaderRoundingModeRTZFloat64: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFormatPackFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub formatPack: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub fragmentDensityMapDeferred: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub subsampledLoads: VkBool32,
    pub subsampledCoarseReconstructionEarlyAccess: VkBool32,
    pub maxSubsampledArrayLayers: u32,
    pub maxDescriptorSetSubsampledSamplers: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub fragmentDensityMap: VkBool32,
    pub fragmentDensityMapDynamic: VkBool32,
    pub fragmentDensityMapNonSubsampledImages: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub fragmentDensityMapLayered: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxFragmentDensityMapLayers: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub fragmentDensityMapOffset: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub fragmentDensityOffsetGranularity: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub minFragmentDensityTexelSize: VkExtent2D,
    pub maxFragmentDensityTexelSize: VkExtent2D,
    pub fragmentDensityInvocations: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub fragmentShaderBarycentric: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub triStripVertexOrderIndependentOfProvokingVertex: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub fragmentShaderSampleInterlock: VkBool32,
    pub fragmentShaderPixelInterlock: VkBool32,
    pub fragmentShaderShadingRateInterlock: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub fragmentShadingRateEnums: VkBool32,
    pub supersampleFragmentShadingRates: VkBool32,
    pub noInvocationFragmentShadingRates: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxFragmentShadingRateInvocationCount: VkSampleCountFlagBits,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pipelineFragmentShadingRate: VkBool32,
    pub primitiveFragmentShadingRate: VkBool32,
    pub attachmentFragmentShadingRate: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFragmentShadingRateKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub sampleCounts: VkSampleCountFlags,
    pub fragmentSize: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub minFragmentShadingRateAttachmentTexelSize: VkExtent2D,
    pub maxFragmentShadingRateAttachmentTexelSize: VkExtent2D,
    pub maxFragmentShadingRateAttachmentTexelSizeAspectRatio: u32,
    pub primitiveFragmentShadingRateWithMultipleViewports: VkBool32,
    pub layeredShadingRateAttachments: VkBool32,
    pub fragmentShadingRateNonTrivialCombinerOps: VkBool32,
    pub maxFragmentSize: VkExtent2D,
    pub maxFragmentSizeAspectRatio: u32,
    pub maxFragmentShadingRateCoverageSamples: u32,
    pub maxFragmentShadingRateRasterizationSamples: VkSampleCountFlagBits,
    pub fragmentShadingRateWithShaderDepthStencilWrites: VkBool32,
    pub fragmentShadingRateWithSampleMask: VkBool32,
    pub fragmentShadingRateWithShaderSampleMask: VkBool32,
    pub fragmentShadingRateWithConservativeRasterization: VkBool32,
    pub fragmentShadingRateWithFragmentShaderInterlock: VkBool32,
    pub fragmentShadingRateWithCustomSampleLocations: VkBool32,
    pub fragmentShadingRateStrictMultiplyCombiner: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceFrameBoundaryFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub frameBoundary: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceGlobalPriorityQueryFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub globalPriorityQuery: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub graphicsPipelineLibrary: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub graphicsPipelineLibraryFastLinking: VkBool32,
    pub graphicsPipelineLibraryIndependentInterpolationDecoration: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceGroupProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub physicalDeviceCount: u32,
    pub physicalDevices: [VkPhysicalDevice; VK_MAX_DEVICE_GROUP_SIZE as usize],
    pub subsetAllocation: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceHdrVividFeaturesHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub hdrVivid: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceHostImageCopyFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub hostImageCopy: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceHostImageCopyProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub copySrcLayoutCount: u32,
    pub pCopySrcLayouts: *mut VkImageLayout,
    pub copyDstLayoutCount: u32,
    pub pCopyDstLayouts: *mut VkImageLayout,
    pub optimalTilingLayoutUUID: [u8; VK_UUID_SIZE as usize],
    pub identicalMemoryTypeRequirements: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceHostQueryResetFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub hostQueryReset: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceIDProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub deviceUUID: [u8; VK_UUID_SIZE as usize],
    pub driverUUID: [u8; VK_UUID_SIZE as usize],
    pub deviceLUID: [u8; VK_LUID_SIZE as usize],
    pub deviceNodeMask: u32,
    pub deviceLUIDValid: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub image2DViewOf3D: VkBool32,
    pub sampler2DViewOf3D: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub imageAlignmentControl: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceImageAlignmentControlPropertiesMESA {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub supportedImageAlignmentMask: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceImageCompressionControlFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub imageCompressionControl: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub imageCompressionControlSwapchain: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub drmFormatModifier: u64,
    pub sharingMode: VkSharingMode,
    pub queueFamilyIndexCount: u32,
    pub pQueueFamilyIndices: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceImageFormatInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub format: VkFormat,
    pub typ: VkImageType,
    pub tiling: VkImageTiling,
    pub usage: VkImageUsageFlags,
    pub flags: VkImageCreateFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceImageProcessing2FeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub textureBlockMatch2: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceImageProcessing2PropertiesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxBlockMatchWindow: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceImageProcessingFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub textureSampleWeighted: VkBool32,
    pub textureBoxFilter: VkBool32,
    pub textureBlockMatch: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceImageProcessingPropertiesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxWeightFilterPhases: u32,
    pub maxWeightFilterDimension: VkExtent2D,
    pub maxBlockMatchRegion: VkExtent2D,
    pub maxBoxFilterBlockSize: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceImageRobustnessFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub robustImageAccess: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub imageSlicedViewOf3D: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceImageViewImageFormatInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub imageViewType: VkImageViewType,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceImageViewMinLodFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub minLod: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceImagelessFramebufferFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub imagelessFramebuffer: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceIndexTypeUint8Features {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub indexTypeUint8: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub inheritedViewportScissor2D: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceInlineUniformBlockFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub inlineUniformBlock: VkBool32,
    pub descriptorBindingInlineUniformBlockUpdateAfterBind: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceInlineUniformBlockProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxInlineUniformBlockSize: u32,
    pub maxPerStageDescriptorInlineUniformBlocks: u32,
    pub maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: u32,
    pub maxDescriptorSetInlineUniformBlocks: u32,
    pub maxDescriptorSetUpdateAfterBindInlineUniformBlocks: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub invocationMask: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceLayeredApiPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub vendorID: u32,
    pub deviceID: u32,
    pub layeredAPI: VkPhysicalDeviceLayeredApiKHR,
    pub deviceName: [c_char; VK_MAX_PHYSICAL_DEVICE_NAME_SIZE as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceLayeredApiPropertiesListKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub layeredApiCount: u32,
    pub pLayeredApis: *mut VkPhysicalDeviceLayeredApiPropertiesKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceLayeredApiVulkanPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub properties: VkPhysicalDeviceProperties2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceLayeredDriverPropertiesMSFT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub underlyingAPI: VkLayeredDriverUnderlyingApiMSFT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceLegacyDitheringFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub legacyDithering: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub legacyVertexAttributes: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub nativeUnalignedPerformance: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceLimits {
    pub maxImageDimension1D: u32,
    pub maxImageDimension2D: u32,
    pub maxImageDimension3D: u32,
    pub maxImageDimensionCube: u32,
    pub maxImageArrayLayers: u32,
    pub maxTexelBufferElements: u32,
    pub maxUniformBufferRange: u32,
    pub maxStorageBufferRange: u32,
    pub maxPushConstantsSize: u32,
    pub maxMemoryAllocationCount: u32,
    pub maxSamplerAllocationCount: u32,
    pub bufferImageGranularity: VkDeviceSize,
    pub sparseAddressSpaceSize: VkDeviceSize,
    pub maxBoundDescriptorSets: u32,
    pub maxPerStageDescriptorSamplers: u32,
    pub maxPerStageDescriptorUniformBuffers: u32,
    pub maxPerStageDescriptorStorageBuffers: u32,
    pub maxPerStageDescriptorSampledImages: u32,
    pub maxPerStageDescriptorStorageImages: u32,
    pub maxPerStageDescriptorInputAttachments: u32,
    pub maxPerStageResources: u32,
    pub maxDescriptorSetSamplers: u32,
    pub maxDescriptorSetUniformBuffers: u32,
    pub maxDescriptorSetUniformBuffersDynamic: u32,
    pub maxDescriptorSetStorageBuffers: u32,
    pub maxDescriptorSetStorageBuffersDynamic: u32,
    pub maxDescriptorSetSampledImages: u32,
    pub maxDescriptorSetStorageImages: u32,
    pub maxDescriptorSetInputAttachments: u32,
    pub maxVertexInputAttributes: u32,
    pub maxVertexInputBindings: u32,
    pub maxVertexInputAttributeOffset: u32,
    pub maxVertexInputBindingStride: u32,
    pub maxVertexOutputComponents: u32,
    pub maxTessellationGenerationLevel: u32,
    pub maxTessellationPatchSize: u32,
    pub maxTessellationControlPerVertexInputComponents: u32,
    pub maxTessellationControlPerVertexOutputComponents: u32,
    pub maxTessellationControlPerPatchOutputComponents: u32,
    pub maxTessellationControlTotalOutputComponents: u32,
    pub maxTessellationEvaluationInputComponents: u32,
    pub maxTessellationEvaluationOutputComponents: u32,
    pub maxGeometryShaderInvocations: u32,
    pub maxGeometryInputComponents: u32,
    pub maxGeometryOutputComponents: u32,
    pub maxGeometryOutputVertices: u32,
    pub maxGeometryTotalOutputComponents: u32,
    pub maxFragmentInputComponents: u32,
    pub maxFragmentOutputAttachments: u32,
    pub maxFragmentDualSrcAttachments: u32,
    pub maxFragmentCombinedOutputResources: u32,
    pub maxComputeSharedMemorySize: u32,
    pub maxComputeWorkGroupCount: [u32; 3 as usize],
    pub maxComputeWorkGroupInvocations: u32,
    pub maxComputeWorkGroupSize: [u32; 3 as usize],
    pub subPixelPrecisionBits: u32,
    pub subTexelPrecisionBits: u32,
    pub mipmapPrecisionBits: u32,
    pub maxDrawIndexedIndexValue: u32,
    pub maxDrawIndirectCount: u32,
    pub maxSamplerLodBias: f32,
    pub maxSamplerAnisotropy: f32,
    pub maxViewports: u32,
    pub maxViewportDimensions: [u32; 2 as usize],
    pub viewportBoundsRange: [f32; 2 as usize],
    pub viewportSubPixelBits: u32,
    pub minMemoryMapAlignment: usize,
    pub minTexelBufferOffsetAlignment: VkDeviceSize,
    pub minUniformBufferOffsetAlignment: VkDeviceSize,
    pub minStorageBufferOffsetAlignment: VkDeviceSize,
    pub minTexelOffset: i32,
    pub maxTexelOffset: u32,
    pub minTexelGatherOffset: i32,
    pub maxTexelGatherOffset: u32,
    pub minInterpolationOffset: f32,
    pub maxInterpolationOffset: f32,
    pub subPixelInterpolationOffsetBits: u32,
    pub maxFramebufferWidth: u32,
    pub maxFramebufferHeight: u32,
    pub maxFramebufferLayers: u32,
    pub framebufferColorSampleCounts: VkSampleCountFlags,
    pub framebufferDepthSampleCounts: VkSampleCountFlags,
    pub framebufferStencilSampleCounts: VkSampleCountFlags,
    pub framebufferNoAttachmentsSampleCounts: VkSampleCountFlags,
    pub maxColorAttachments: u32,
    pub sampledImageColorSampleCounts: VkSampleCountFlags,
    pub sampledImageIntegerSampleCounts: VkSampleCountFlags,
    pub sampledImageDepthSampleCounts: VkSampleCountFlags,
    pub sampledImageStencilSampleCounts: VkSampleCountFlags,
    pub storageImageSampleCounts: VkSampleCountFlags,
    pub maxSampleMaskWords: u32,
    pub timestampComputeAndGraphics: VkBool32,
    pub timestampPeriod: f32,
    pub maxClipDistances: u32,
    pub maxCullDistances: u32,
    pub maxCombinedClipAndCullDistances: u32,
    pub discreteQueuePriorities: u32,
    pub pointSizeRange: [f32; 2 as usize],
    pub lineWidthRange: [f32; 2 as usize],
    pub pointSizeGranularity: f32,
    pub lineWidthGranularity: f32,
    pub strictLines: VkBool32,
    pub standardSampleLocations: VkBool32,
    pub optimalBufferCopyOffsetAlignment: VkDeviceSize,
    pub optimalBufferCopyRowPitchAlignment: VkDeviceSize,
    pub nonCoherentAtomSize: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceLineRasterizationFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub rectangularLines: VkBool32,
    pub bresenhamLines: VkBool32,
    pub smoothLines: VkBool32,
    pub stippledRectangularLines: VkBool32,
    pub stippledBresenhamLines: VkBool32,
    pub stippledSmoothLines: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceLineRasterizationProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub lineSubPixelPrecisionBits: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub linearColorAttachment: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMaintenance10FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maintenance10: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMaintenance10PropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub rgba4OpaqueBlackSwizzled: VkBool32,
    pub resolveSrgbFormatAppliesTransferFunction: VkBool32,
    pub resolveSrgbFormatSupportsTransferFunctionControl: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMaintenance3Properties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxPerSetDescriptors: u32,
    pub maxMemoryAllocationSize: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMaintenance4Features {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maintenance4: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMaintenance4Properties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxBufferSize: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMaintenance5Features {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maintenance5: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMaintenance5Properties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub earlyFragmentMultisampleCoverageAfterSampleCounting: VkBool32,
    pub earlyFragmentSampleMaskTestBeforeSampleCounting: VkBool32,
    pub depthStencilSwizzleOneSupport: VkBool32,
    pub polygonModePointSize: VkBool32,
    pub nonStrictSinglePixelWideLinesUseParallelogram: VkBool32,
    pub nonStrictWideLinesUseParallelogram: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMaintenance6Features {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maintenance6: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMaintenance6Properties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub blockTexelViewCompatibleMultipleLayers: VkBool32,
    pub maxCombinedImageSamplerDescriptorCount: u32,
    pub fragmentShadingRateClampCombinerInputs: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMaintenance7FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maintenance7: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMaintenance7PropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub robustFragmentShadingRateAttachmentAccess: VkBool32,
    pub separateDepthStencilAttachmentAccess: VkBool32,
    pub maxDescriptorSetTotalUniformBuffersDynamic: u32,
    pub maxDescriptorSetTotalStorageBuffersDynamic: u32,
    pub maxDescriptorSetTotalBuffersDynamic: u32,
    pub maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic: u32,
    pub maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic: u32,
    pub maxDescriptorSetUpdateAfterBindTotalBuffersDynamic: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMaintenance8FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maintenance8: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMaintenance9FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maintenance9: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMaintenance9PropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub image2DViewOf3DSparse: VkBool32,
    pub defaultVertexAttributeValue: VkDefaultVertexAttributeValueKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub memoryMapPlaced: VkBool32,
    pub memoryMapRangePlaced: VkBool32,
    pub memoryUnmapReserve: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub minPlacedMemoryMapAlignment: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMemoryBudgetPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub heapBudget: [VkDeviceSize; VK_MAX_MEMORY_HEAPS as usize],
    pub heapUsage: [VkDeviceSize; VK_MAX_MEMORY_HEAPS as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMemoryDecompressionFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub memoryDecompression: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMemoryDecompressionPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub decompressionMethods: VkMemoryDecompressionMethodFlagsEXT,
    pub maxDecompressionIndirectCount: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMemoryPriorityFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub memoryPriority: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMemoryProperties {
    pub memoryTypeCount: u32,
    pub memoryTypes: [VkMemoryType; VK_MAX_MEMORY_TYPES as usize],
    pub memoryHeapCount: u32,
    pub memoryHeaps: [VkMemoryHeap; VK_MAX_MEMORY_HEAPS as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMemoryProperties2 {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub memoryProperties: VkPhysicalDeviceMemoryProperties,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMeshShaderFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub taskShader: VkBool32,
    pub meshShader: VkBool32,
    pub multiviewMeshShader: VkBool32,
    pub primitiveFragmentShadingRateMeshShader: VkBool32,
    pub meshShaderQueries: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMeshShaderFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub taskShader: VkBool32,
    pub meshShader: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMeshShaderPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxTaskWorkGroupTotalCount: u32,
    pub maxTaskWorkGroupCount: [u32; 3 as usize],
    pub maxTaskWorkGroupInvocations: u32,
    pub maxTaskWorkGroupSize: [u32; 3 as usize],
    pub maxTaskPayloadSize: u32,
    pub maxTaskSharedMemorySize: u32,
    pub maxTaskPayloadAndSharedMemorySize: u32,
    pub maxMeshWorkGroupTotalCount: u32,
    pub maxMeshWorkGroupCount: [u32; 3 as usize],
    pub maxMeshWorkGroupInvocations: u32,
    pub maxMeshWorkGroupSize: [u32; 3 as usize],
    pub maxMeshSharedMemorySize: u32,
    pub maxMeshPayloadAndSharedMemorySize: u32,
    pub maxMeshOutputMemorySize: u32,
    pub maxMeshPayloadAndOutputMemorySize: u32,
    pub maxMeshOutputComponents: u32,
    pub maxMeshOutputVertices: u32,
    pub maxMeshOutputPrimitives: u32,
    pub maxMeshOutputLayers: u32,
    pub maxMeshMultiviewViewCount: u32,
    pub meshOutputPerVertexGranularity: u32,
    pub meshOutputPerPrimitiveGranularity: u32,
    pub maxPreferredTaskWorkGroupInvocations: u32,
    pub maxPreferredMeshWorkGroupInvocations: u32,
    pub prefersLocalInvocationVertexOutput: VkBool32,
    pub prefersLocalInvocationPrimitiveOutput: VkBool32,
    pub prefersCompactVertexOutput: VkBool32,
    pub prefersCompactPrimitiveOutput: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMeshShaderPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxDrawMeshTasksCount: u32,
    pub maxTaskWorkGroupInvocations: u32,
    pub maxTaskWorkGroupSize: [u32; 3 as usize],
    pub maxTaskTotalMemorySize: u32,
    pub maxTaskOutputCount: u32,
    pub maxMeshWorkGroupInvocations: u32,
    pub maxMeshWorkGroupSize: [u32; 3 as usize],
    pub maxMeshTotalMemorySize: u32,
    pub maxMeshOutputVertices: u32,
    pub maxMeshOutputPrimitives: u32,
    pub maxMeshMultiviewViewCount: u32,
    pub meshOutputPerVertexGranularity: u32,
    pub meshOutputPerPrimitiveGranularity: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMultiDrawFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub multiDraw: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMultiDrawPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxMultiDrawCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub multisampledRenderToSingleSampled: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMultiviewFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub multiview: VkBool32,
    pub multiviewGeometryShader: VkBool32,
    pub multiviewTessellationShader: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub perViewPositionAllComponents: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub multiviewPerViewRenderAreas: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub multiviewPerViewViewports: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMultiviewProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxMultiviewViewCount: u32,
    pub maxMultiviewInstanceIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub mutableDescriptorType: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub nestedCommandBuffer: VkBool32,
    pub nestedCommandBufferRendering: VkBool32,
    pub nestedCommandBufferSimultaneousUse: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxCommandBufferNestingLevel: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub nonSeamlessCubeMap: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceOpacityMicromapFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub micromap: VkBool32,
    pub micromapCaptureReplay: VkBool32,
    pub micromapHostCommands: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceOpacityMicromapPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxOpacity2StateSubdivisionLevel: u32,
    pub maxOpacity4StateSubdivisionLevel: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceOpticalFlowFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub opticalFlow: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceOpticalFlowPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub supportedOutputGridSizes: VkOpticalFlowGridSizeFlagsNV,
    pub supportedHintGridSizes: VkOpticalFlowGridSizeFlagsNV,
    pub hintSupported: VkBool32,
    pub costSupported: VkBool32,
    pub bidirectionalFlowSupported: VkBool32,
    pub globalFlowSupported: VkBool32,
    pub minWidth: u32,
    pub minHeight: u32,
    pub maxWidth: u32,
    pub maxHeight: u32,
    pub maxNumRegionsOfInterest: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePCIBusInfoPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pciDomain: u32,
    pub pciBus: u32,
    pub pciDevice: u32,
    pub pciFunction: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pageableDeviceLocalMemory: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub partitionedAccelerationStructure: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxPartitionCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub perStageDescriptorSet: VkBool32,
    pub dynamicPipelineLayout: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePerformanceCountersByRegionFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub performanceCountersByRegion: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePerformanceCountersByRegionPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxPerRegionPerformanceCounters: u32,
    pub performanceCounterRegionSize: VkExtent2D,
    pub rowStrideAlignment: u32,
    pub regionAlignment: u32,
    pub identityTransformOrder: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePerformanceQueryFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub performanceCounterQueryPools: VkBool32,
    pub performanceCounterMultipleQueryPools: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePerformanceQueryPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub allowCommandBufferQueryCopies: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePipelineBinaryFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pipelineBinaries: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePipelineBinaryPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pipelineBinaryInternalCache: VkBool32,
    pub pipelineBinaryInternalCacheControl: VkBool32,
    pub pipelineBinaryPrefersInternalCache: VkBool32,
    pub pipelineBinaryPrecompiledInternalCache: VkBool32,
    pub pipelineBinaryCompressedData: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pipelineCacheIncrementalMode: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePipelineCreationCacheControlFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pipelineCreationCacheControl: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pipelineExecutableInfo: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pipelineLibraryGroupHandles: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePipelineOpacityMicromapFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pipelineOpacityMicromap: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePipelinePropertiesFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pipelinePropertiesIdentifier: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePipelineProtectedAccessFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pipelineProtectedAccess: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePipelineRobustnessFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pipelineRobustness: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePipelineRobustnessProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub defaultRobustnessStorageBuffers: VkPipelineRobustnessBufferBehavior,
    pub defaultRobustnessUniformBuffers: VkPipelineRobustnessBufferBehavior,
    pub defaultRobustnessVertexInputs: VkPipelineRobustnessBufferBehavior,
    pub defaultRobustnessImages: VkPipelineRobustnessImageBehavior,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePointClippingProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pointClippingBehavior: VkPointClippingBehavior,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePresentBarrierFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentBarrier: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePresentId2FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentId2: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePresentIdFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentId: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentModeFifoLatestReady: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePresentTimingFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentTiming: VkBool32,
    pub presentAtAbsoluteTime: VkBool32,
    pub presentAtRelativeTime: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePresentWait2FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentWait2: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePresentWaitFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentWait: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub primitiveTopologyListRestart: VkBool32,
    pub primitiveTopologyPatchListRestart: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub primitivesGeneratedQuery: VkBool32,
    pub primitivesGeneratedQueryWithRasterizerDiscard: VkBool32,
    pub primitivesGeneratedQueryWithNonZeroStreams: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePrivateDataFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub privateData: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceProperties {
    pub apiVersion: u32,
    pub driverVersion: u32,
    pub vendorID: u32,
    pub deviceID: u32,
    pub deviceType: VkPhysicalDeviceType,
    pub deviceName: [c_char; VK_MAX_PHYSICAL_DEVICE_NAME_SIZE as usize],
    pub pipelineCacheUUID: [u8; VK_UUID_SIZE as usize],
    pub limits: VkPhysicalDeviceLimits,
    pub sparseProperties: VkPhysicalDeviceSparseProperties,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceProperties2 {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub properties: VkPhysicalDeviceProperties,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceProtectedMemoryFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub protectedMemory: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceProtectedMemoryProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub protectedNoFault: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceProvokingVertexFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub provokingVertexLast: VkBool32,
    pub transformFeedbackPreservesProvokingVertex: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceProvokingVertexPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub provokingVertexModePerPipeline: VkBool32,
    pub transformFeedbackPreservesTriangleFanProvokingVertex: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDevicePushDescriptorProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxPushDescriptors: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub queueFamilyIndex: u32,
    pub engineType: VkPhysicalDeviceDataGraphProcessingEngineTypeARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub formatRgba10x6WithoutYCbCrSampler: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub rasterizationOrderColorAttachmentAccess: VkBool32,
    pub rasterizationOrderDepthAttachmentAccess: VkBool32,
    pub rasterizationOrderStencilAttachmentAccess: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRawAccessChainsFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderRawAccessChains: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRayQueryFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub rayQuery: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub rayTracingInvocationReorder: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub rayTracingInvocationReorder: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub rayTracingInvocationReorderReorderingHint: VkRayTracingInvocationReorderModeEXT,
    pub maxShaderBindingTableRecordIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub rayTracingInvocationReorderReorderingHint: VkRayTracingInvocationReorderModeEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub spheres: VkBool32,
    pub linearSweptSpheres: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub rayTracingMaintenance1: VkBool32,
    pub rayTracingPipelineTraceRaysIndirect2: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub rayTracingMotionBlur: VkBool32,
    pub rayTracingMotionBlurPipelineTraceRaysIndirect: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub rayTracingPipeline: VkBool32,
    pub rayTracingPipelineShaderGroupHandleCaptureReplay: VkBool32,
    pub rayTracingPipelineShaderGroupHandleCaptureReplayMixed: VkBool32,
    pub rayTracingPipelineTraceRaysIndirect: VkBool32,
    pub rayTraversalPrimitiveCulling: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderGroupHandleSize: u32,
    pub maxRayRecursionDepth: u32,
    pub maxShaderGroupStride: u32,
    pub shaderGroupBaseAlignment: u32,
    pub shaderGroupHandleCaptureReplaySize: u32,
    pub maxRayDispatchInvocationCount: u32,
    pub shaderGroupHandleAlignment: u32,
    pub maxRayHitAttributeSize: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub rayTracingPositionFetch: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRayTracingPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderGroupHandleSize: u32,
    pub maxRecursionDepth: u32,
    pub maxShaderGroupStride: u32,
    pub shaderGroupBaseAlignment: u32,
    pub maxGeometryCount: u64,
    pub maxInstanceCount: u64,
    pub maxTriangleCount: u64,
    pub maxDescriptorSetAccelerationStructures: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRayTracingValidationFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub rayTracingValidation: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub relaxedLineRasterization: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRenderPassStripedFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub renderPassStriped: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRenderPassStripedPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub renderPassStripeGranularity: VkExtent2D,
    pub maxRenderPassStripes: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub representativeFragmentTest: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRobustness2FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub robustBufferAccess2: VkBool32,
    pub robustImageAccess2: VkBool32,
    pub nullDescriptor: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceRobustness2PropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub robustStorageBufferAccessSizeAlignment: VkDeviceSize,
    pub robustUniformBufferAccessSizeAlignment: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSampleLocationsPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub sampleLocationSampleCounts: VkSampleCountFlags,
    pub maxSampleLocationGridSize: VkExtent2D,
    pub sampleLocationCoordinateRange: [f32; 2 as usize],
    pub sampleLocationSubPixelBits: u32,
    pub variableSampleLocations: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSamplerFilterMinmaxProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub filterMinmaxSingleComponentFormats: VkBool32,
    pub filterMinmaxImageComponentMapping: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSamplerYcbcrConversionFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub samplerYcbcrConversion: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceScalarBlockLayoutFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub scalarBlockLayout: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSchedulingControlsFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub schedulingControls: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSchedulingControlsPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub schedulingControlsFlags: VkPhysicalDeviceSchedulingControlsFlagsARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub separateDepthStencilLayouts: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShader64BitIndexingFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shader64BitIndexing: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderFloat16VectorAtomics: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderAtomicInt64Features {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderBufferInt64Atomics: VkBool32,
    pub shaderSharedInt64Atomics: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderBfloat16FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderBFloat16Type: VkBool32,
    pub shaderBFloat16DotProduct: VkBool32,
    pub shaderBFloat16CooperativeMatrix: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderClockFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderSubgroupClock: VkBool32,
    pub shaderDeviceClock: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderCoreBuiltins: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderCoreMask: u64,
    pub shaderCoreCount: u32,
    pub shaderWarpsPerCore: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderCoreProperties2AMD {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderCoreFeatures: VkShaderCorePropertiesFlagsAMD,
    pub activeComputeUnitCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderCorePropertiesAMD {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderEngineCount: u32,
    pub shaderArraysPerEngineCount: u32,
    pub computeUnitsPerShaderArray: u32,
    pub simdPerComputeUnit: u32,
    pub wavefrontsPerSimd: u32,
    pub wavefrontSize: u32,
    pub sgprsPerSimd: u32,
    pub minSgprAllocation: u32,
    pub maxSgprAllocation: u32,
    pub sgprAllocationGranularity: u32,
    pub vgprsPerSimd: u32,
    pub minVgprAllocation: u32,
    pub maxVgprAllocation: u32,
    pub vgprAllocationGranularity: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderCorePropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pixelRate: u32,
    pub texelRate: u32,
    pub fmaRate: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderDemoteToHelperInvocation: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderDrawParametersFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderDrawParameters: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderEarlyAndLateFragmentTests: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderExpectAssumeFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderExpectAssume: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderFloat16Int8Features {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderFloat16: VkBool32,
    pub shaderInt8: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderFloat8FeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderFloat8: VkBool32,
    pub shaderFloat8CooperativeMatrix: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderFloatControls2Features {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderFloatControls2: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderFmaFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderFmaFloat16: VkBool32,
    pub shaderFmaFloat32: VkBool32,
    pub shaderFmaFloat64: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderImageInt64Atomics: VkBool32,
    pub sparseImageInt64Atomics: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub imageFootprint: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderIntegerDotProductFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderIntegerDotProduct: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderIntegerDotProductProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderIntegerFunctions2: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderLongVectorFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub longVector: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderLongVectorPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxVectorComponents: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderMaximalReconvergence: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderModuleIdentifier: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderModuleIdentifierAlgorithmUUID: [u8; VK_UUID_SIZE as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderObjectFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderObject: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderObjectPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderBinaryUUID: [u8; VK_UUID_SIZE as usize],
    pub shaderBinaryVersion: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderQuadControlFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderQuadControl: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderRelaxedExtendedInstruction: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderReplicatedComposites: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderSMBuiltins: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderSMCount: u32,
    pub shaderWarpsPerSM: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderSubgroupExtendedTypes: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderSubgroupRotateFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderSubgroupRotate: VkBool32,
    pub shaderSubgroupRotateClustered: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderSubgroupUniformControlFlow: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderTerminateInvocationFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderTerminateInvocation: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderTileImageFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderTileImageColorReadAccess: VkBool32,
    pub shaderTileImageDepthReadAccess: VkBool32,
    pub shaderTileImageStencilReadAccess: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderTileImagePropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderTileImageCoherentReadAccelerated: VkBool32,
    pub shaderTileImageReadSampleFromPixelRateInvocation: VkBool32,
    pub shaderTileImageReadFromHelperInvocation: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderUniformBufferUnsizedArray: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShaderUntypedPointersFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderUntypedPointers: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShadingRateImageFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shadingRateImage: VkBool32,
    pub shadingRateCoarseSampleOrder: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceShadingRateImagePropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shadingRateTexelSize: VkExtent2D,
    pub shadingRatePaletteSize: u32,
    pub shadingRateMaxCoarseSamples: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSparseImageFormatInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub format: VkFormat,
    pub typ: VkImageType,
    pub samples: VkSampleCountFlagBits,
    pub usage: VkImageUsageFlags,
    pub tiling: VkImageTiling,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSparseProperties {
    pub residencyStandard2DBlockShape: VkBool32,
    pub residencyStandard2DMultisampleBlockShape: VkBool32,
    pub residencyStandard3DBlockShape: VkBool32,
    pub residencyAlignedMipSize: VkBool32,
    pub residencyNonResidentStrict: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSubgroupProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub subgroupSize: u32,
    pub supportedStages: VkShaderStageFlags,
    pub supportedOperations: VkSubgroupFeatureFlags,
    pub quadOperationsInAllStages: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSubgroupSizeControlFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub subgroupSizeControl: VkBool32,
    pub computeFullSubgroups: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSubgroupSizeControlProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub minSubgroupSize: u32,
    pub maxSubgroupSize: u32,
    pub maxComputeWorkgroupSubgroups: u32,
    pub requiredSubgroupSizeStages: VkShaderStageFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub subpassMergeFeedback: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub subpassShading: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxSubpassShadingWorkgroupSizeAspectRatio: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSurfaceInfo2KHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub surface: VkSurfaceKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub swapchainMaintenance1: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceSynchronization2Features {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub synchronization2: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceTensorFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub tensorNonPacked: VkBool32,
    pub shaderTensorAccess: VkBool32,
    pub shaderStorageTensorArrayDynamicIndexing: VkBool32,
    pub shaderStorageTensorArrayNonUniformIndexing: VkBool32,
    pub descriptorBindingStorageTensorUpdateAfterBind: VkBool32,
    pub tensors: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceTensorPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxTensorDimensionCount: u32,
    pub maxTensorElements: u64,
    pub maxPerDimensionTensorElements: u64,
    pub maxTensorStride: i64,
    pub maxTensorSize: u64,
    pub maxTensorShaderAccessArrayLength: u32,
    pub maxTensorShaderAccessSize: u32,
    pub maxDescriptorSetStorageTensors: u32,
    pub maxPerStageDescriptorSetStorageTensors: u32,
    pub maxDescriptorSetUpdateAfterBindStorageTensors: u32,
    pub maxPerStageDescriptorUpdateAfterBindStorageTensors: u32,
    pub shaderStorageTensorArrayNonUniformIndexingNative: VkBool32,
    pub shaderTensorSupportedStages: VkShaderStageFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub texelBufferAlignment: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceTexelBufferAlignmentProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub storageTexelBufferOffsetAlignmentBytes: VkDeviceSize,
    pub storageTexelBufferOffsetSingleTexelAlignment: VkBool32,
    pub uniformTexelBufferOffsetAlignmentBytes: VkDeviceSize,
    pub uniformTexelBufferOffsetSingleTexelAlignment: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub textureCompressionASTC_3D: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub textureCompressionASTC_HDR: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub tileMemoryHeap: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub queueSubmitBoundary: VkBool32,
    pub tileBufferTransfers: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceTilePropertiesFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub tileProperties: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceTileShadingFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceTileShadingPropertiesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxApronSize: u32,
    pub preferNonCoherent: VkBool32,
    pub tileGranularity: VkExtent2D,
    pub maxTileShadingRate: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceTimelineSemaphoreFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub timelineSemaphore: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceTimelineSemaphoreProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxTimelineSemaphoreValueDifference: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceToolProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_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],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceTransformFeedbackFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub transformFeedback: VkBool32,
    pub geometryStreams: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceTransformFeedbackPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxTransformFeedbackStreams: u32,
    pub maxTransformFeedbackBuffers: u32,
    pub maxTransformFeedbackBufferSize: VkDeviceSize,
    pub maxTransformFeedbackStreamDataSize: u32,
    pub maxTransformFeedbackBufferDataSize: u32,
    pub maxTransformFeedbackBufferDataStride: u32,
    pub transformFeedbackQueries: VkBool32,
    pub transformFeedbackStreamsLinesTriangles: VkBool32,
    pub transformFeedbackRasterizationStreamSelect: VkBool32,
    pub transformFeedbackDraw: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub unifiedImageLayouts: VkBool32,
    pub unifiedImageLayoutsVideo: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub uniformBufferStandardLayout: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVariablePointersFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub variablePointersStorageBuffer: VkBool32,
    pub variablePointers: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVertexAttributeDivisorFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub vertexAttributeInstanceRateDivisor: VkBool32,
    pub vertexAttributeInstanceRateZeroDivisor: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVertexAttributeDivisorProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxVertexAttribDivisor: u32,
    pub supportsNonZeroFirstInstance: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxVertexAttribDivisor: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub vertexAttributeRobustness: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub vertexInputDynamicState: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVideoDecodeVP9FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub videoDecodeVP9: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub videoEncodeAV1: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub videoEncodeIntraRefresh: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pVideoProfile: *const VkVideoProfileInfoKHR,
    pub qualityLevel: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub videoEncodeQuantizationMap: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub videoEncodeRgbConversion: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVideoFormatInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub imageUsage: VkImageUsageFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub videoMaintenance1: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVideoMaintenance2FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub videoMaintenance2: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVulkan11Features {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub storageBuffer16BitAccess: VkBool32,
    pub uniformAndStorageBuffer16BitAccess: VkBool32,
    pub storagePushConstant16: VkBool32,
    pub storageInputOutput16: VkBool32,
    pub multiview: VkBool32,
    pub multiviewGeometryShader: VkBool32,
    pub multiviewTessellationShader: VkBool32,
    pub variablePointersStorageBuffer: VkBool32,
    pub variablePointers: VkBool32,
    pub protectedMemory: VkBool32,
    pub samplerYcbcrConversion: VkBool32,
    pub shaderDrawParameters: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVulkan11Properties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub deviceUUID: [u8; VK_UUID_SIZE as usize],
    pub driverUUID: [u8; VK_UUID_SIZE as usize],
    pub deviceLUID: [u8; VK_LUID_SIZE as usize],
    pub deviceNodeMask: u32,
    pub deviceLUIDValid: VkBool32,
    pub subgroupSize: u32,
    pub subgroupSupportedStages: VkShaderStageFlags,
    pub subgroupSupportedOperations: VkSubgroupFeatureFlags,
    pub subgroupQuadOperationsInAllStages: VkBool32,
    pub pointClippingBehavior: VkPointClippingBehavior,
    pub maxMultiviewViewCount: u32,
    pub maxMultiviewInstanceIndex: u32,
    pub protectedNoFault: VkBool32,
    pub maxPerSetDescriptors: u32,
    pub maxMemoryAllocationSize: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVulkan12Features {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub samplerMirrorClampToEdge: VkBool32,
    pub drawIndirectCount: VkBool32,
    pub storageBuffer8BitAccess: VkBool32,
    pub uniformAndStorageBuffer8BitAccess: VkBool32,
    pub storagePushConstant8: VkBool32,
    pub shaderBufferInt64Atomics: VkBool32,
    pub shaderSharedInt64Atomics: VkBool32,
    pub shaderFloat16: VkBool32,
    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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVulkan12Properties {
    pub sType: VkStructureType,
    pub pNext: *mut c_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,
    pub shaderSignedZeroInfNanPreserveFloat16: VkBool32,
    pub shaderSignedZeroInfNanPreserveFloat32: VkBool32,
    pub shaderSignedZeroInfNanPreserveFloat64: VkBool32,
    pub shaderDenormPreserveFloat16: VkBool32,
    pub shaderDenormPreserveFloat32: VkBool32,
    pub shaderDenormPreserveFloat64: VkBool32,
    pub shaderDenormFlushToZeroFloat16: VkBool32,
    pub shaderDenormFlushToZeroFloat32: VkBool32,
    pub shaderDenormFlushToZeroFloat64: VkBool32,
    pub shaderRoundingModeRTEFloat16: VkBool32,
    pub shaderRoundingModeRTEFloat32: VkBool32,
    pub shaderRoundingModeRTEFloat64: VkBool32,
    pub shaderRoundingModeRTZFloat16: VkBool32,
    pub shaderRoundingModeRTZFloat32: VkBool32,
    pub shaderRoundingModeRTZFloat64: VkBool32,
    pub maxUpdateAfterBindDescriptorsInAllPools: u32,
    pub shaderUniformBufferArrayNonUniformIndexingNative: VkBool32,
    pub shaderSampledImageArrayNonUniformIndexingNative: VkBool32,
    pub shaderStorageBufferArrayNonUniformIndexingNative: VkBool32,
    pub shaderStorageImageArrayNonUniformIndexingNative: VkBool32,
    pub shaderInputAttachmentArrayNonUniformIndexingNative: VkBool32,
    pub robustBufferAccessUpdateAfterBind: VkBool32,
    pub quadDivergentImplicitLod: VkBool32,
    pub maxPerStageDescriptorUpdateAfterBindSamplers: u32,
    pub maxPerStageDescriptorUpdateAfterBindUniformBuffers: u32,
    pub maxPerStageDescriptorUpdateAfterBindStorageBuffers: u32,
    pub maxPerStageDescriptorUpdateAfterBindSampledImages: u32,
    pub maxPerStageDescriptorUpdateAfterBindStorageImages: u32,
    pub maxPerStageDescriptorUpdateAfterBindInputAttachments: u32,
    pub maxPerStageUpdateAfterBindResources: u32,
    pub maxDescriptorSetUpdateAfterBindSamplers: u32,
    pub maxDescriptorSetUpdateAfterBindUniformBuffers: u32,
    pub maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: u32,
    pub maxDescriptorSetUpdateAfterBindStorageBuffers: u32,
    pub maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: u32,
    pub maxDescriptorSetUpdateAfterBindSampledImages: u32,
    pub maxDescriptorSetUpdateAfterBindStorageImages: u32,
    pub maxDescriptorSetUpdateAfterBindInputAttachments: u32,
    pub supportedDepthResolveModes: VkResolveModeFlags,
    pub supportedStencilResolveModes: VkResolveModeFlags,
    pub independentResolveNone: VkBool32,
    pub independentResolve: VkBool32,
    pub filterMinmaxSingleComponentFormats: VkBool32,
    pub filterMinmaxImageComponentMapping: VkBool32,
    pub maxTimelineSemaphoreValueDifference: u64,
    pub framebufferIntegerColorSampleCounts: VkSampleCountFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVulkan13Features {
    pub sType: VkStructureType,
    pub pNext: *mut c_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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVulkan13Properties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub minSubgroupSize: u32,
    pub maxSubgroupSize: u32,
    pub maxComputeWorkgroupSubgroups: u32,
    pub requiredSubgroupSizeStages: VkShaderStageFlags,
    pub maxInlineUniformBlockSize: u32,
    pub maxPerStageDescriptorInlineUniformBlocks: u32,
    pub maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: u32,
    pub maxDescriptorSetInlineUniformBlocks: u32,
    pub maxDescriptorSetUpdateAfterBindInlineUniformBlocks: u32,
    pub maxInlineUniformTotalSize: u32,
    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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVulkan14Features {
    pub sType: VkStructureType,
    pub pNext: *mut c_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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVulkan14Properties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub lineSubPixelPrecisionBits: u32,
    pub maxVertexAttribDivisor: u32,
    pub supportsNonZeroFirstInstance: VkBool32,
    pub maxPushDescriptors: u32,
    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: u32,
    pub fragmentShadingRateClampCombinerInputs: VkBool32,
    pub defaultRobustnessStorageBuffers: VkPipelineRobustnessBufferBehavior,
    pub defaultRobustnessUniformBuffers: VkPipelineRobustnessBufferBehavior,
    pub defaultRobustnessVertexInputs: VkPipelineRobustnessBufferBehavior,
    pub defaultRobustnessImages: VkPipelineRobustnessImageBehavior,
    pub copySrcLayoutCount: u32,
    pub pCopySrcLayouts: *mut VkImageLayout,
    pub copyDstLayoutCount: u32,
    pub pCopyDstLayouts: *mut VkImageLayout,
    pub optimalTilingLayoutUUID: [u8; VK_UUID_SIZE as usize],
    pub identicalMemoryTypeRequirements: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceVulkanMemoryModelFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub vulkanMemoryModel: VkBool32,
    pub vulkanMemoryModelDeviceScope: VkBool32,
    pub vulkanMemoryModelAvailabilityVisibilityChains: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub workgroupMemoryExplicitLayout: VkBool32,
    pub workgroupMemoryExplicitLayoutScalarBlockLayout: VkBool32,
    pub workgroupMemoryExplicitLayout8BitAccess: VkBool32,
    pub workgroupMemoryExplicitLayout16BitAccess: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub ycbcr2plane444Formats: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub ycbcrDegamma: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub ycbcrImageArrays: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub zeroInitializeDeviceMemory: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub shaderZeroInitializeWorkgroupMemory: VkBool32,
}

#[repr(C)]
pub struct VkPhysicalDevice_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineBinaryCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pKeysAndDataInfo: *const VkPipelineBinaryKeysAndDataKHR,
    pub pipeline: VkPipeline,
    pub pPipelineCreateInfo: *const VkPipelineCreateInfoKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineBinaryDataInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pipelineBinary: VkPipelineBinaryKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineBinaryDataKHR {
    pub dataSize: usize,
    pub pData: *mut c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineBinaryHandlesInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pipelineBinaryCount: u32,
    pub pPipelineBinaries: *mut VkPipelineBinaryKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineBinaryInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub binaryCount: u32,
    pub pPipelineBinaries: *const VkPipelineBinaryKHR,
}

#[repr(C)]
pub struct VkPipelineBinaryKHR_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineBinaryKeyKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub keySize: u32,
    pub key: [u8; VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineBinaryKeysAndDataKHR {
    pub binaryCount: u32,
    pub pPipelineBinaryKeys: *const VkPipelineBinaryKeyKHR,
    pub pPipelineBinaryData: *const VkPipelineBinaryDataKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineCacheCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineCacheCreateFlags,
    pub initialDataSize: usize,
    pub pInitialData: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineCacheHeaderVersionDataGraphQCOM {
    pub headerSize: u32,
    pub headerVersion: VkPipelineCacheHeaderVersion,
    pub cacheType: VkDataGraphModelCacheTypeQCOM,
    pub cacheVersion: u32,
    pub toolchainVersion: [u32; VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineCacheHeaderVersionOne {
    pub headerSize: u32,
    pub headerVersion: VkPipelineCacheHeaderVersion,
    pub vendorID: u32,
    pub deviceID: u32,
    pub pipelineCacheUUID: [u8; VK_UUID_SIZE as usize],
}

#[repr(C)]
pub struct VkPipelineCache_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcPremultiplied: VkBool32,
    pub dstPremultiplied: VkBool32,
    pub blendOverlap: VkBlendOverlapEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineColorBlendStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineColorBlendStateCreateFlags,
    pub logicOpEnable: VkBool32,
    pub logicOp: VkLogicOp,
    pub attachmentCount: u32,
    pub pAttachments: *const VkPipelineColorBlendAttachmentState,
    pub blendConstants: [f32; 4 as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineColorWriteCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub attachmentCount: u32,
    pub pColorWriteEnables: *const VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineCompilerControlCreateInfoAMD {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub compilerControlFlags: VkPipelineCompilerControlFlagsAMD,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineCoverageModulationStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineCoverageModulationStateCreateFlagsNV,
    pub coverageModulationMode: VkCoverageModulationModeNV,
    pub coverageModulationTableEnable: VkBool32,
    pub coverageModulationTableCount: u32,
    pub pCoverageModulationTable: *const f32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineCoverageReductionStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineCoverageReductionStateCreateFlagsNV,
    pub coverageReductionMode: VkCoverageReductionModeNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineCoverageToColorStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineCoverageToColorStateCreateFlagsNV,
    pub coverageToColorEnable: VkBool32,
    pub coverageToColorLocation: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineCreateFlags2CreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineCreateFlags2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineCreationFeedback {
    pub flags: VkPipelineCreationFeedbackFlags,
    pub duration: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineCreationFeedbackCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pPipelineCreationFeedback: *mut VkPipelineCreationFeedback,
    pub pipelineStageCreationFeedbackCount: u32,
    pub pPipelineStageCreationFeedbacks: *mut VkPipelineCreationFeedback,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineDepthStencilStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineDepthStencilStateCreateFlags,
    pub depthTestEnable: VkBool32,
    pub depthWriteEnable: VkBool32,
    pub depthCompareOp: VkCompareOp,
    pub depthBoundsTestEnable: VkBool32,
    pub stencilTestEnable: VkBool32,
    pub front: VkStencilOpState,
    pub back: VkStencilOpState,
    pub minDepthBounds: f32,
    pub maxDepthBounds: f32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineDiscardRectangleStateCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineDiscardRectangleStateCreateFlagsEXT,
    pub discardRectangleMode: VkDiscardRectangleModeEXT,
    pub discardRectangleCount: u32,
    pub pDiscardRectangles: *const VkRect2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineDynamicStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineDynamicStateCreateFlags,
    pub dynamicStateCount: u32,
    pub pDynamicStates: *const VkDynamicState,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineExecutableInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pipeline: VkPipeline,
    pub executableIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineExecutableInternalRepresentationKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_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: usize,
    pub pData: *mut c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineExecutablePropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_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: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineExecutableStatisticKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub maxFragmentDensityMapLayers: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub shadingRateType: VkFragmentShadingRateTypeNV,
    pub shadingRate: VkFragmentShadingRateNV,
    pub combinerOps: [VkFragmentShadingRateCombinerOpKHR; 2 as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineFragmentShadingRateStateCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub fragmentSize: VkExtent2D,
    pub combinerOps: [VkFragmentShadingRateCombinerOpKHR; 2 as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineIndirectDeviceAddressInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pipelineBindPoint: VkPipelineBindPoint,
    pub pipeline: VkPipeline,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pipeline: VkPipeline,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineInputAssemblyStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineInputAssemblyStateCreateFlags,
    pub topology: VkPrimitiveTopology,
    pub primitiveRestartEnable: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineLayoutCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineLayoutCreateFlags,
    pub setLayoutCount: u32,
    pub pSetLayouts: *const VkDescriptorSetLayout,
    pub pushConstantRangeCount: u32,
    pub pPushConstantRanges: *const VkPushConstantRange,
}

#[repr(C)]
pub struct VkPipelineLayout_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineLibraryCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub libraryCount: u32,
    pub pLibraries: *const VkPipeline,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineMultisampleStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineMultisampleStateCreateFlags,
    pub rasterizationSamples: VkSampleCountFlagBits,
    pub sampleShadingEnable: VkBool32,
    pub minSampleShading: f32,
    pub pSampleMask: *const VkSampleMask,
    pub alphaToCoverageEnable: VkBool32,
    pub alphaToOneEnable: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelinePropertiesIdentifierEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pipelineIdentifier: [u8; VK_UUID_SIZE as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineRasterizationConservativeStateCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineRasterizationConservativeStateCreateFlagsEXT,
    pub conservativeRasterizationMode: VkConservativeRasterizationModeEXT,
    pub extraPrimitiveOverestimationSize: f32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineRasterizationDepthClipStateCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineRasterizationDepthClipStateCreateFlagsEXT,
    pub depthClipEnable: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineRasterizationLineStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub lineRasterizationMode: VkLineRasterizationMode,
    pub stippledLineEnable: VkBool32,
    pub lineStippleFactor: u32,
    pub lineStipplePattern: u16,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub provokingVertexMode: VkProvokingVertexModeEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineRasterizationStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineRasterizationStateCreateFlags,
    pub depthClampEnable: VkBool32,
    pub rasterizerDiscardEnable: VkBool32,
    pub polygonMode: VkPolygonMode,
    pub cullMode: VkCullModeFlags,
    pub frontFace: VkFrontFace,
    pub depthBiasEnable: VkBool32,
    pub depthBiasConstantFactor: f32,
    pub depthBiasClamp: f32,
    pub depthBiasSlopeFactor: f32,
    pub lineWidth: f32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineRasterizationStateRasterizationOrderAMD {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub rasterizationOrder: VkRasterizationOrderAMD,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineRasterizationStateStreamCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineRasterizationStateStreamCreateFlagsEXT,
    pub rasterizationStream: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineRenderingCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub viewMask: u32,
    pub colorAttachmentCount: u32,
    pub pColorAttachmentFormats: *const VkFormat,
    pub depthAttachmentFormat: VkFormat,
    pub stencilAttachmentFormat: VkFormat,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub representativeFragmentTestEnable: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineRobustnessCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub storageBuffers: VkPipelineRobustnessBufferBehavior,
    pub uniformBuffers: VkPipelineRobustnessBufferBehavior,
    pub vertexInputs: VkPipelineRobustnessBufferBehavior,
    pub images: VkPipelineRobustnessImageBehavior,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineSampleLocationsStateCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub sampleLocationsEnable: VkBool32,
    pub sampleLocationsInfo: VkSampleLocationsInfoEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineShaderStageCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineShaderStageCreateFlags,
    pub stage: VkShaderStageFlagBits,
    pub module: VkShaderModule,
    pub pName: *const c_char,
    pub pSpecializationInfo: *const VkSpecializationInfo,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub identifierSize: u32,
    pub pIdentifier: *const u8,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub requiredSubgroupSize: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineTessellationDomainOriginStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub domainOrigin: VkTessellationDomainOrigin,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineTessellationStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineTessellationStateCreateFlags,
    pub patchControlPoints: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineVertexInputDivisorStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub vertexBindingDivisorCount: u32,
    pub pVertexBindingDivisors: *const VkVertexInputBindingDivisorDescription,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineVertexInputStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineVertexInputStateCreateFlags,
    pub vertexBindingDescriptionCount: u32,
    pub pVertexBindingDescriptions: *const VkVertexInputBindingDescription,
    pub vertexAttributeDescriptionCount: u32,
    pub pVertexAttributeDescriptions: *const VkVertexInputAttributeDescription,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub sampleOrderType: VkCoarseSampleOrderTypeNV,
    pub customSampleOrderCount: u32,
    pub pCustomSampleOrders: *const VkCoarseSampleOrderCustomNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineViewportDepthClampControlCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub depthClampMode: VkDepthClampModeEXT,
    pub pDepthClampRange: *const VkDepthClampRangeEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineViewportDepthClipControlCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub negativeOneToOne: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineViewportExclusiveScissorStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub exclusiveScissorCount: u32,
    pub pExclusiveScissors: *const VkRect2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineViewportShadingRateImageStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub shadingRateImageEnable: VkBool32,
    pub viewportCount: u32,
    pub pShadingRatePalettes: *const VkShadingRatePaletteNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineViewportStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineViewportStateCreateFlags,
    pub viewportCount: u32,
    pub pViewports: *const VkViewport,
    pub scissorCount: u32,
    pub pScissors: *const VkRect2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineViewportSwizzleStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineViewportSwizzleStateCreateFlagsNV,
    pub viewportCount: u32,
    pub pViewportSwizzles: *const VkViewportSwizzleNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPipelineViewportWScalingStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub viewportWScalingEnable: VkBool32,
    pub viewportCount: u32,
    pub pViewportWScalings: *const VkViewportWScalingNV,
}

#[repr(C)]
pub struct VkPipeline_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPresentId2KHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub swapchainCount: u32,
    pub pPresentIds: *const u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPresentIdKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub swapchainCount: u32,
    pub pPresentIds: *const u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPresentInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub waitSemaphoreCount: u32,
    pub pWaitSemaphores: *const VkSemaphore,
    pub swapchainCount: u32,
    pub pSwapchains: *const VkSwapchainKHR,
    pub pImageIndices: *const u32,
    pub pResults: *mut VkResult,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPresentRegionKHR {
    pub rectangleCount: u32,
    pub pRectangles: *const VkRectLayerKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPresentRegionsKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub swapchainCount: u32,
    pub pRegions: *const VkPresentRegionKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPresentStageTimeEXT {
    pub stage: VkPresentStageFlagsEXT,
    pub time: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPresentTimeGOOGLE {
    pub presentID: u32,
    pub desiredPresentTime: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPresentTimesInfoGOOGLE {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub swapchainCount: u32,
    pub pTimes: *const VkPresentTimeGOOGLE,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPresentTimingInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPresentTimingInfoFlagsEXT,
    pub targetTime: u64,
    pub timeDomainId: u64,
    pub presentStageQueries: VkPresentStageFlagsEXT,
    pub targetTimeDomainPresentStage: VkPresentStageFlagsEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPresentTimingSurfaceCapabilitiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentTimingSupported: VkBool32,
    pub presentAtAbsoluteTimeSupported: VkBool32,
    pub presentAtRelativeTimeSupported: VkBool32,
    pub presentStageQueries: VkPresentStageFlagsEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPresentTimingsInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub swapchainCount: u32,
    pub pTimingInfos: *const VkPresentTimingInfoEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPresentWait2InfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub presentId: u64,
    pub timeout: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPrivateDataSlotCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPrivateDataSlotCreateFlags,
}

#[repr(C)]
pub struct VkPrivateDataSlot_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkProtectedSubmitInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub protectedSubmit: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPushConstantRange {
    pub stageFlags: VkShaderStageFlags,
    pub offset: u32,
    pub size: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPushConstantsInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub layout: VkPipelineLayout,
    pub stageFlags: VkShaderStageFlags,
    pub offset: u32,
    pub size: u32,
    pub pValues: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPushDescriptorSetInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stageFlags: VkShaderStageFlags,
    pub layout: VkPipelineLayout,
    pub set: u32,
    pub descriptorWriteCount: u32,
    pub pDescriptorWrites: *const VkWriteDescriptorSet,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkPushDescriptorSetWithTemplateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub descriptorUpdateTemplate: VkDescriptorUpdateTemplate,
    pub layout: VkPipelineLayout,
    pub set: u32,
    pub pData: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkQueryLowLatencySupportNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pQueriedLowLatencyData: *mut c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkQueryPoolCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkQueryPoolCreateFlags,
    pub queryType: VkQueryType,
    pub queryCount: u32,
    pub pipelineStatistics: VkQueryPipelineStatisticFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkQueryPoolPerformanceCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub queueFamilyIndex: u32,
    pub counterIndexCount: u32,
    pub pCounterIndices: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkQueryPoolPerformanceQueryCreateInfoINTEL {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub performanceCountersSampling: VkQueryPoolSamplingModeINTEL,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub encodeFeedbackFlags: VkVideoEncodeFeedbackFlagsKHR,
}

#[repr(C)]
pub struct VkQueryPool_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkQueueFamilyCheckpointProperties2NV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub checkpointExecutionStageMask: VkPipelineStageFlags2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkQueueFamilyCheckpointPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub checkpointExecutionStageMask: VkPipelineStageFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub foreignSemaphoreHandleTypes: VkExternalSemaphoreHandleTypeFlags,
    pub foreignMemoryHandleTypes: VkExternalMemoryHandleTypeFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkQueueFamilyDataGraphPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub engine: VkPhysicalDeviceDataGraphProcessingEngineARM,
    pub operation: VkPhysicalDeviceDataGraphOperationSupportARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkQueueFamilyGlobalPriorityProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub priorityCount: u32,
    pub priorities: [VkQueueGlobalPriority; VK_MAX_GLOBAL_PRIORITY_SIZE as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkQueueFamilyOwnershipTransferPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub optimalImageTransferToQueueFamilies: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkQueueFamilyProperties {
    pub queueFlags: VkQueueFlags,
    pub queueCount: u32,
    pub timestampValidBits: u32,
    pub minImageTransferGranularity: VkExtent3D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkQueueFamilyProperties2 {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub queueFamilyProperties: VkQueueFamilyProperties,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkQueueFamilyQueryResultStatusPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub queryResultStatusSupport: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkQueueFamilyVideoPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub videoCodecOperations: VkVideoCodecOperationFlagsKHR,
}

#[repr(C)]
pub struct VkQueue_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub allowClusterAccelerationStructure: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRayTracingPipelineCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineCreateFlags,
    pub stageCount: u32,
    pub pStages: *const VkPipelineShaderStageCreateInfo,
    pub groupCount: u32,
    pub pGroups: *const VkRayTracingShaderGroupCreateInfoKHR,
    pub maxPipelineRayRecursionDepth: u32,
    pub pLibraryInfo: *const VkPipelineLibraryCreateInfoKHR,
    pub pLibraryInterface: *const VkRayTracingPipelineInterfaceCreateInfoKHR,
    pub pDynamicState: *const VkPipelineDynamicStateCreateInfo,
    pub layout: VkPipelineLayout,
    pub basePipelineHandle: VkPipeline,
    pub basePipelineIndex: i32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRayTracingPipelineCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkPipelineCreateFlags,
    pub stageCount: u32,
    pub pStages: *const VkPipelineShaderStageCreateInfo,
    pub groupCount: u32,
    pub pGroups: *const VkRayTracingShaderGroupCreateInfoNV,
    pub maxRecursionDepth: u32,
    pub layout: VkPipelineLayout,
    pub basePipelineHandle: VkPipeline,
    pub basePipelineIndex: i32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRayTracingPipelineInterfaceCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub maxPipelineRayPayloadSize: u32,
    pub maxPipelineRayHitAttributeSize: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRayTracingShaderGroupCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub typ: VkRayTracingShaderGroupTypeKHR,
    pub generalShader: u32,
    pub closestHitShader: u32,
    pub anyHitShader: u32,
    pub intersectionShader: u32,
    pub pShaderGroupCaptureReplayHandle: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRayTracingShaderGroupCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub typ: VkRayTracingShaderGroupTypeKHR,
    pub generalShader: u32,
    pub closestHitShader: u32,
    pub anyHitShader: u32,
    pub intersectionShader: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRect2D {
    pub offset: VkOffset2D,
    pub extent: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRectLayerKHR {
    pub offset: VkOffset2D,
    pub extent: VkExtent2D,
    pub layer: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRefreshCycleDurationGOOGLE {
    pub refreshDuration: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkReleaseCapturedPipelineDataInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub pipeline: VkPipeline,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkReleaseSwapchainImagesInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub swapchain: VkSwapchainKHR,
    pub imageIndexCount: u32,
    pub pImageIndices: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassAttachmentBeginInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub attachmentCount: u32,
    pub pAttachments: *const VkImageView,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassBeginInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub renderPass: VkRenderPass,
    pub framebuffer: VkFramebuffer,
    pub renderArea: VkRect2D,
    pub clearValueCount: u32,
    pub pClearValues: *const VkClearValue,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkRenderPassCreateFlags,
    pub attachmentCount: u32,
    pub pAttachments: *const VkAttachmentDescription,
    pub subpassCount: u32,
    pub pSubpasses: *const VkSubpassDescription,
    pub dependencyCount: u32,
    pub pDependencies: *const VkSubpassDependency,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassCreateInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkRenderPassCreateFlags,
    pub attachmentCount: u32,
    pub pAttachments: *const VkAttachmentDescription2,
    pub subpassCount: u32,
    pub pSubpasses: *const VkSubpassDescription2,
    pub dependencyCount: u32,
    pub pDependencies: *const VkSubpassDependency2,
    pub correlatedViewMaskCount: u32,
    pub pCorrelatedViewMasks: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassCreationControlEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub disallowMerging: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassCreationFeedbackCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pRenderPassFeedback: *mut VkRenderPassCreationFeedbackInfoEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassCreationFeedbackInfoEXT {
    pub postMergeSubpassCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassFragmentDensityMapCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub fragmentDensityMapAttachment: VkAttachmentReference,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub fragmentDensityOffsetCount: u32,
    pub pFragmentDensityOffsets: *const VkOffset2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassInputAttachmentAspectCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub aspectReferenceCount: u32,
    pub pAspectReferences: *const VkInputAttachmentAspectReference,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassMultiviewCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub subpassCount: u32,
    pub pViewMasks: *const u32,
    pub dependencyCount: u32,
    pub pViewOffsets: *const i32,
    pub correlationMaskCount: u32,
    pub pCorrelationMasks: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassPerformanceCountersByRegionBeginInfoARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub counterAddressCount: u32,
    pub pCounterAddresses: *const VkDeviceAddress,
    pub serializeRegions: VkBool32,
    pub counterIndexCount: u32,
    pub pCounterIndices: *mut u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassSampleLocationsBeginInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub attachmentInitialSampleLocationsCount: u32,
    pub pAttachmentInitialSampleLocations: *const VkAttachmentSampleLocationsEXT,
    pub postSubpassSampleLocationsCount: u32,
    pub pPostSubpassSampleLocations: *const VkSubpassSampleLocationsEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassStripeBeginInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stripeInfoCount: u32,
    pub pStripeInfos: *const VkRenderPassStripeInfoARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassStripeInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stripeArea: VkRect2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassStripeSubmitInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stripeSemaphoreInfoCount: u32,
    pub pStripeSemaphoreInfos: *const VkSemaphoreSubmitInfo,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassSubpassFeedbackCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pSubpassFeedback: *mut VkRenderPassSubpassFeedbackInfoEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassSubpassFeedbackInfoEXT {
    pub subpassMergeStatus: VkSubpassMergeStatusEXT,
    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
    pub postMergeIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassTileShadingCreateInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkTileShadingRenderPassFlagsQCOM,
    pub tileApronSize: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderPassTransformBeginInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub transform: VkSurfaceTransformFlagBitsKHR,
}

#[repr(C)]
pub struct VkRenderPass_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderingAreaInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub viewMask: u32,
    pub colorAttachmentCount: u32,
    pub pColorAttachmentFormats: *const VkFormat,
    pub depthAttachmentFormat: VkFormat,
    pub stencilAttachmentFormat: VkFormat,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderingAttachmentFlagsInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkRenderingAttachmentFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderingAttachmentInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub imageView: VkImageView,
    pub imageLayout: VkImageLayout,
    pub resolveMode: VkResolveModeFlagBits,
    pub resolveImageView: VkImageView,
    pub resolveImageLayout: VkImageLayout,
    pub loadOp: VkAttachmentLoadOp,
    pub storeOp: VkAttachmentStoreOp,
    pub clearValue: VkClearValue,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderingAttachmentLocationInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub colorAttachmentCount: u32,
    pub pColorAttachmentLocations: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderingEndInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderingFragmentDensityMapAttachmentInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub imageView: VkImageView,
    pub imageLayout: VkImageLayout,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderingFragmentShadingRateAttachmentInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub imageView: VkImageView,
    pub imageLayout: VkImageLayout,
    pub shadingRateAttachmentTexelSize: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderingInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkRenderingFlags,
    pub renderArea: VkRect2D,
    pub layerCount: u32,
    pub viewMask: u32,
    pub colorAttachmentCount: u32,
    pub pColorAttachments: *const VkRenderingAttachmentInfo,
    pub pDepthAttachment: *const VkRenderingAttachmentInfo,
    pub pStencilAttachment: *const VkRenderingAttachmentInfo,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkRenderingInputAttachmentIndexInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub colorAttachmentCount: u32,
    pub pColorAttachmentInputIndices: *const u32,
    pub pDepthInputAttachmentIndex: *const u32,
    pub pStencilInputAttachmentIndex: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkResolveImageInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcImage: VkImage,
    pub srcImageLayout: VkImageLayout,
    pub dstImage: VkImage,
    pub dstImageLayout: VkImageLayout,
    pub regionCount: u32,
    pub pRegions: *const VkImageResolve2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkResolveImageModeInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkResolveImageFlagsKHR,
    pub resolveMode: VkResolveModeFlagBits,
    pub stencilResolveMode: VkResolveModeFlagBits,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSRTDataNV {
    pub sx: f32,
    pub a: f32,
    pub b: f32,
    pub pvx: f32,
    pub sy: f32,
    pub c: f32,
    pub pvy: f32,
    pub sz: f32,
    pub pvz: f32,
    pub qx: f32,
    pub qy: f32,
    pub qz: f32,
    pub qw: f32,
    pub tx: f32,
    pub ty: f32,
    pub tz: f32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSampleLocationEXT {
    pub x: f32,
    pub y: f32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSampleLocationsInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub sampleLocationsPerPixel: VkSampleCountFlagBits,
    pub sampleLocationGridSize: VkExtent2D,
    pub sampleLocationsCount: u32,
    pub pSampleLocations: *const VkSampleLocationEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSamplerBlockMatchWindowCreateInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub windowExtent: VkExtent2D,
    pub windowCompareMode: VkBlockMatchWindowCompareModeQCOM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSamplerBorderColorComponentMappingCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub components: VkComponentMapping,
    pub srgb: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSamplerCaptureDescriptorDataInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub sampler: VkSampler,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSamplerCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkSamplerCreateFlags,
    pub magFilter: VkFilter,
    pub minFilter: VkFilter,
    pub mipmapMode: VkSamplerMipmapMode,
    pub addressModeU: VkSamplerAddressMode,
    pub addressModeV: VkSamplerAddressMode,
    pub addressModeW: VkSamplerAddressMode,
    pub mipLodBias: f32,
    pub anisotropyEnable: VkBool32,
    pub maxAnisotropy: f32,
    pub compareEnable: VkBool32,
    pub compareOp: VkCompareOp,
    pub minLod: f32,
    pub maxLod: f32,
    pub borderColor: VkBorderColor,
    pub unnormalizedCoordinates: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSamplerCubicWeightsCreateInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub cubicWeights: VkCubicFilterWeightsQCOM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSamplerCustomBorderColorCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub customBorderColor: VkClearColorValue,
    pub format: VkFormat,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSamplerReductionModeCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub reductionMode: VkSamplerReductionMode,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSamplerYcbcrConversionCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSamplerYcbcrConversionImageFormatProperties {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub combinedImageSamplerDescriptorCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSamplerYcbcrConversionInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub conversion: VkSamplerYcbcrConversion,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub enableYDegamma: VkBool32,
    pub enableCbCrDegamma: VkBool32,
}

#[repr(C)]
pub struct VkSamplerYcbcrConversion_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[repr(C)]
pub struct VkSampler_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSemaphoreCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkSemaphoreCreateFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSemaphoreGetFdInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub semaphore: VkSemaphore,
    pub handleType: VkExternalSemaphoreHandleTypeFlagBits,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSemaphoreSignalInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub semaphore: VkSemaphore,
    pub value: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSemaphoreSubmitInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub semaphore: VkSemaphore,
    pub value: u64,
    pub stageMask: VkPipelineStageFlags2,
    pub deviceIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSemaphoreTypeCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub semaphoreType: VkSemaphoreType,
    pub initialValue: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSemaphoreWaitInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkSemaphoreWaitFlags,
    pub semaphoreCount: u32,
    pub pSemaphores: *const VkSemaphore,
    pub pValues: *const u64,
}

#[repr(C)]
pub struct VkSemaphore_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSetDescriptorBufferOffsetsInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stageFlags: VkShaderStageFlags,
    pub layout: VkPipelineLayout,
    pub firstSet: u32,
    pub setCount: u32,
    pub pBufferIndices: *const u32,
    pub pOffsets: *const VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSetLatencyMarkerInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub presentID: u64,
    pub marker: VkLatencyMarkerNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSetStateFlagsIndirectCommandNV {
    pub data: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkShaderCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkShaderCreateFlagsEXT,
    pub stage: VkShaderStageFlagBits,
    pub nextStage: VkShaderStageFlags,
    pub codeType: VkShaderCodeTypeEXT,
    pub codeSize: usize,
    pub pCode: *const c_void,
    pub pName: *const c_char,
    pub setLayoutCount: u32,
    pub pSetLayouts: *const VkDescriptorSetLayout,
    pub pushConstantRangeCount: u32,
    pub pPushConstantRanges: *const VkPushConstantRange,
    pub pSpecializationInfo: *const VkSpecializationInfo,
}

#[repr(C)]
pub struct VkShaderEXT_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkShaderModuleCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkShaderModuleCreateFlags,
    pub codeSize: usize,
    pub pCode: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkShaderModuleIdentifierEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub identifierSize: u32,
    pub identifier: [u8; VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkShaderModuleValidationCacheCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub validationCache: VkValidationCacheEXT,
}

#[repr(C)]
pub struct VkShaderModule_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkShaderResourceUsageAMD {
    pub numUsedVgprs: u32,
    pub numUsedSgprs: u32,
    pub ldsSizePerLocalWorkGroup: u32,
    pub ldsUsageSizeInBytes: usize,
    pub scratchMemUsageInBytes: usize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkShaderStatisticsInfoAMD {
    pub shaderStageMask: VkShaderStageFlags,
    pub resourceUsage: VkShaderResourceUsageAMD,
    pub numPhysicalVgprs: u32,
    pub numPhysicalSgprs: u32,
    pub numAvailableVgprs: u32,
    pub numAvailableSgprs: u32,
    pub computeWorkGroupSize: [u32; 3 as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkShadingRatePaletteNV {
    pub shadingRatePaletteEntryCount: u32,
    pub pShadingRatePaletteEntries: *const VkShadingRatePaletteEntryNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSharedPresentSurfaceCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub sharedPresentSupportedUsageFlags: VkImageUsageFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSparseBufferMemoryBindInfo {
    pub buffer: VkBuffer,
    pub bindCount: u32,
    pub pBinds: *const VkSparseMemoryBind,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSparseImageFormatProperties {
    pub aspectMask: VkImageAspectFlags,
    pub imageGranularity: VkExtent3D,
    pub flags: VkSparseImageFormatFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSparseImageFormatProperties2 {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub properties: VkSparseImageFormatProperties,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSparseImageMemoryBind {
    pub subresource: VkImageSubresource,
    pub offset: VkOffset3D,
    pub extent: VkExtent3D,
    pub memory: VkDeviceMemory,
    pub memoryOffset: VkDeviceSize,
    pub flags: VkSparseMemoryBindFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSparseImageMemoryBindInfo {
    pub image: VkImage,
    pub bindCount: u32,
    pub pBinds: *const VkSparseImageMemoryBind,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSparseImageMemoryRequirements {
    pub formatProperties: VkSparseImageFormatProperties,
    pub imageMipTailFirstLod: u32,
    pub imageMipTailSize: VkDeviceSize,
    pub imageMipTailOffset: VkDeviceSize,
    pub imageMipTailStride: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSparseImageMemoryRequirements2 {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub memoryRequirements: VkSparseImageMemoryRequirements,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSparseImageOpaqueMemoryBindInfo {
    pub image: VkImage,
    pub bindCount: u32,
    pub pBinds: *const VkSparseMemoryBind,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSparseMemoryBind {
    pub resourceOffset: VkDeviceSize,
    pub size: VkDeviceSize,
    pub memory: VkDeviceMemory,
    pub memoryOffset: VkDeviceSize,
    pub flags: VkSparseMemoryBindFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSpecializationInfo {
    pub mapEntryCount: u32,
    pub pMapEntries: *const VkSpecializationMapEntry,
    pub dataSize: usize,
    pub pData: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSpecializationMapEntry {
    pub constantID: u32,
    pub offset: u32,
    pub size: usize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkStencilOpState {
    pub failOp: VkStencilOp,
    pub passOp: VkStencilOp,
    pub depthFailOp: VkStencilOp,
    pub compareOp: VkCompareOp,
    pub compareMask: u32,
    pub writeMask: u32,
    pub reference: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkStridedDeviceAddressNV {
    pub startAddress: VkDeviceAddress,
    pub strideInBytes: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkStridedDeviceAddressRangeKHR {
    pub address: VkDeviceAddress,
    pub size: VkDeviceSize,
    pub stride: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkStridedDeviceAddressRegionKHR {
    pub deviceAddress: VkDeviceAddress,
    pub stride: VkDeviceSize,
    pub size: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSubmitInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub waitSemaphoreCount: u32,
    pub pWaitSemaphores: *const VkSemaphore,
    pub pWaitDstStageMask: *const VkPipelineStageFlags,
    pub commandBufferCount: u32,
    pub pCommandBuffers: *const VkCommandBuffer,
    pub signalSemaphoreCount: u32,
    pub pSignalSemaphores: *const VkSemaphore,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSubmitInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkSubmitFlags,
    pub waitSemaphoreInfoCount: u32,
    pub pWaitSemaphoreInfos: *const VkSemaphoreSubmitInfo,
    pub commandBufferInfoCount: u32,
    pub pCommandBufferInfos: *const VkCommandBufferSubmitInfo,
    pub signalSemaphoreInfoCount: u32,
    pub pSignalSemaphoreInfos: *const VkSemaphoreSubmitInfo,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSubpassBeginInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub contents: VkSubpassContents,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSubpassDependency {
    pub srcSubpass: u32,
    pub dstSubpass: u32,
    pub srcStageMask: VkPipelineStageFlags,
    pub dstStageMask: VkPipelineStageFlags,
    pub srcAccessMask: VkAccessFlags,
    pub dstAccessMask: VkAccessFlags,
    pub dependencyFlags: VkDependencyFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSubpassDependency2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcSubpass: u32,
    pub dstSubpass: u32,
    pub srcStageMask: VkPipelineStageFlags,
    pub dstStageMask: VkPipelineStageFlags,
    pub srcAccessMask: VkAccessFlags,
    pub dstAccessMask: VkAccessFlags,
    pub dependencyFlags: VkDependencyFlags,
    pub viewOffset: i32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSubpassDescription {
    pub flags: VkSubpassDescriptionFlags,
    pub pipelineBindPoint: VkPipelineBindPoint,
    pub inputAttachmentCount: u32,
    pub pInputAttachments: *const VkAttachmentReference,
    pub colorAttachmentCount: u32,
    pub pColorAttachments: *const VkAttachmentReference,
    pub pResolveAttachments: *const VkAttachmentReference,
    pub pDepthStencilAttachment: *const VkAttachmentReference,
    pub preserveAttachmentCount: u32,
    pub pPreserveAttachments: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSubpassDescription2 {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkSubpassDescriptionFlags,
    pub pipelineBindPoint: VkPipelineBindPoint,
    pub viewMask: u32,
    pub inputAttachmentCount: u32,
    pub pInputAttachments: *const VkAttachmentReference2,
    pub colorAttachmentCount: u32,
    pub pColorAttachments: *const VkAttachmentReference2,
    pub pResolveAttachments: *const VkAttachmentReference2,
    pub pDepthStencilAttachment: *const VkAttachmentReference2,
    pub preserveAttachmentCount: u32,
    pub pPreserveAttachments: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSubpassDescriptionDepthStencilResolve {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub depthResolveMode: VkResolveModeFlagBits,
    pub stencilResolveMode: VkResolveModeFlagBits,
    pub pDepthStencilResolveAttachment: *const VkAttachmentReference2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSubpassEndInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSubpassResolvePerformanceQueryEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub optimal: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSubpassSampleLocationsEXT {
    pub subpassIndex: u32,
    pub sampleLocationsInfo: VkSampleLocationsInfoEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSubpassShadingPipelineCreateInfoHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub renderPass: VkRenderPass,
    pub subpass: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSubresourceHostMemcpySize {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub size: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSubresourceLayout {
    pub offset: VkDeviceSize,
    pub size: VkDeviceSize,
    pub rowPitch: VkDeviceSize,
    pub arrayPitch: VkDeviceSize,
    pub depthPitch: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSubresourceLayout2 {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub subresourceLayout: VkSubresourceLayout,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSurfaceCapabilities2EXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub minImageCount: u32,
    pub maxImageCount: u32,
    pub currentExtent: VkExtent2D,
    pub minImageExtent: VkExtent2D,
    pub maxImageExtent: VkExtent2D,
    pub maxImageArrayLayers: u32,
    pub supportedTransforms: VkSurfaceTransformFlagsKHR,
    pub currentTransform: VkSurfaceTransformFlagBitsKHR,
    pub supportedCompositeAlpha: VkCompositeAlphaFlagsKHR,
    pub supportedUsageFlags: VkImageUsageFlags,
    pub supportedSurfaceCounters: VkSurfaceCounterFlagsEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSurfaceCapabilities2KHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub surfaceCapabilities: VkSurfaceCapabilitiesKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSurfaceCapabilitiesKHR {
    pub minImageCount: u32,
    pub maxImageCount: u32,
    pub currentExtent: VkExtent2D,
    pub minImageExtent: VkExtent2D,
    pub maxImageExtent: VkExtent2D,
    pub maxImageArrayLayers: u32,
    pub supportedTransforms: VkSurfaceTransformFlagsKHR,
    pub currentTransform: VkSurfaceTransformFlagBitsKHR,
    pub supportedCompositeAlpha: VkCompositeAlphaFlagsKHR,
    pub supportedUsageFlags: VkImageUsageFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSurfaceCapabilitiesPresentBarrierNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentBarrierSupported: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSurfaceCapabilitiesPresentId2KHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentId2Supported: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSurfaceCapabilitiesPresentWait2KHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentWait2Supported: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSurfaceFormat2KHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub surfaceFormat: VkSurfaceFormatKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSurfaceFormatKHR {
    pub format: VkFormat,
    pub colorSpace: VkColorSpaceKHR,
}

#[repr(C)]
pub struct VkSurfaceKHR_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSurfacePresentModeCompatibilityKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentModeCount: u32,
    pub pPresentModes: *mut VkPresentModeKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSurfacePresentModeKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentMode: VkPresentModeKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSurfacePresentScalingCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub supportedPresentScaling: VkPresentScalingFlagsKHR,
    pub supportedPresentGravityX: VkPresentGravityFlagsKHR,
    pub supportedPresentGravityY: VkPresentGravityFlagsKHR,
    pub minScaledImageExtent: VkExtent2D,
    pub maxScaledImageExtent: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSurfaceProtectedCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub supportsProtected: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSwapchainCalibratedTimestampInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub swapchain: VkSwapchainKHR,
    pub presentStage: VkPresentStageFlagsEXT,
    pub timeDomainId: u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSwapchainCounterCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub surfaceCounters: VkSurfaceCounterFlagsEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSwapchainCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkSwapchainCreateFlagsKHR,
    pub surface: VkSurfaceKHR,
    pub minImageCount: u32,
    pub imageFormat: VkFormat,
    pub imageColorSpace: VkColorSpaceKHR,
    pub imageExtent: VkExtent2D,
    pub imageArrayLayers: u32,
    pub imageUsage: VkImageUsageFlags,
    pub imageSharingMode: VkSharingMode,
    pub queueFamilyIndexCount: u32,
    pub pQueueFamilyIndices: *const u32,
    pub preTransform: VkSurfaceTransformFlagBitsKHR,
    pub compositeAlpha: VkCompositeAlphaFlagBitsKHR,
    pub presentMode: VkPresentModeKHR,
    pub clipped: VkBool32,
    pub oldSwapchain: VkSwapchainKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSwapchainDisplayNativeHdrCreateInfoAMD {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub localDimmingEnable: VkBool32,
}

#[repr(C)]
pub struct VkSwapchainKHR_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSwapchainLatencyCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub latencyModeEnable: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSwapchainPresentBarrierCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub presentBarrierEnable: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSwapchainPresentFenceInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub swapchainCount: u32,
    pub pFences: *const VkFence,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSwapchainPresentModeInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub swapchainCount: u32,
    pub pPresentModes: *const VkPresentModeKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSwapchainPresentModesCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub presentModeCount: u32,
    pub pPresentModes: *const VkPresentModeKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSwapchainPresentScalingCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub scalingBehavior: VkPresentScalingFlagsKHR,
    pub presentGravityX: VkPresentGravityFlagsKHR,
    pub presentGravityY: VkPresentGravityFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSwapchainTimeDomainPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub timeDomainCount: u32,
    pub pTimeDomains: *mut VkTimeDomainKHR,
    pub pTimeDomainIds: *mut u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkSwapchainTimingPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub refreshDuration: u64,
    pub refreshInterval: u64,
}

#[repr(C)]
pub struct VkTensorARM_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTensorCaptureDescriptorDataInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub tensor: VkTensorARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTensorCopyARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub dimensionCount: u32,
    pub pSrcOffset: *const u64,
    pub pDstOffset: *const u64,
    pub pExtent: *const u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTensorCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkTensorCreateFlagsARM,
    pub pDescription: *const VkTensorDescriptionARM,
    pub sharingMode: VkSharingMode,
    pub queueFamilyIndexCount: u32,
    pub pQueueFamilyIndices: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTensorDependencyInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub tensorMemoryBarrierCount: u32,
    pub pTensorMemoryBarriers: *const VkTensorMemoryBarrierARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTensorDescriptionARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub tiling: VkTensorTilingARM,
    pub format: VkFormat,
    pub dimensionCount: u32,
    pub pDimensions: *const i64,
    pub pStrides: *const i64,
    pub usage: VkTensorUsageFlagsARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTensorFormatPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub optimalTilingTensorFeatures: VkFormatFeatureFlags2,
    pub linearTilingTensorFeatures: VkFormatFeatureFlags2,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTensorMemoryBarrierARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub srcStageMask: VkPipelineStageFlags2,
    pub srcAccessMask: VkAccessFlags2,
    pub dstStageMask: VkPipelineStageFlags2,
    pub dstAccessMask: VkAccessFlags2,
    pub srcQueueFamilyIndex: u32,
    pub dstQueueFamilyIndex: u32,
    pub tensor: VkTensorARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTensorMemoryRequirementsInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub tensor: VkTensorARM,
}

#[repr(C)]
pub struct VkTensorViewARM_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTensorViewCaptureDescriptorDataInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub tensorView: VkTensorViewARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTensorViewCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkTensorViewCreateFlagsARM,
    pub tensor: VkTensorARM,
    pub format: VkFormat,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTextureLODGatherFormatPropertiesAMD {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub supportsTextureGatherLODBiasAMD: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTileMemoryBindInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub memory: VkDeviceMemory,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTileMemoryRequirementsQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub size: VkDeviceSize,
    pub alignment: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTileMemorySizeInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub size: VkDeviceSize,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTilePropertiesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub tileSize: VkExtent3D,
    pub apronSize: VkExtent2D,
    pub origin: VkOffset2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTimelineSemaphoreSubmitInfo {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub waitSemaphoreValueCount: u32,
    pub pWaitSemaphoreValues: *const u64,
    pub signalSemaphoreValueCount: u32,
    pub pSignalSemaphoreValues: *const u64,
}

#[derive(Clone, Copy)]
#[repr(C)]
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: u32,
    pub height: u32,
    pub depth: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTraceRaysIndirectCommandKHR {
    pub width: u32,
    pub height: u32,
    pub depth: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkTransformMatrixKHR {
    pub matrix: [[f32; 4 as usize]; 3 as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkValidationCacheCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkValidationCacheCreateFlagsEXT,
    pub initialDataSize: usize,
    pub pInitialData: *const c_void,
}

#[repr(C)]
pub struct VkValidationCacheEXT_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkValidationFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub enabledValidationFeatureCount: u32,
    pub pEnabledValidationFeatures: *const VkValidationFeatureEnableEXT,
    pub disabledValidationFeatureCount: u32,
    pub pDisabledValidationFeatures: *const VkValidationFeatureDisableEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkValidationFlagsEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub disabledValidationCheckCount: u32,
    pub pDisabledValidationChecks: *const VkValidationCheckEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVertexInputAttributeDescription {
    pub location: u32,
    pub binding: u32,
    pub format: VkFormat,
    pub offset: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVertexInputAttributeDescription2EXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub location: u32,
    pub binding: u32,
    pub format: VkFormat,
    pub offset: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVertexInputBindingDescription {
    pub binding: u32,
    pub stride: u32,
    pub inputRate: VkVertexInputRate,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVertexInputBindingDescription2EXT {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub binding: u32,
    pub stride: u32,
    pub inputRate: VkVertexInputRate,
    pub divisor: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVertexInputBindingDivisorDescription {
    pub binding: u32,
    pub divisor: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoBeginCodingInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkVideoBeginCodingFlagsKHR,
    pub videoSession: VkVideoSessionKHR,
    pub videoSessionParameters: VkVideoSessionParametersKHR,
    pub referenceSlotCount: u32,
    pub pReferenceSlots: *const VkVideoReferenceSlotInfoKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub flags: VkVideoCapabilityFlagsKHR,
    pub minBitstreamBufferOffsetAlignment: VkDeviceSize,
    pub minBitstreamBufferSizeAlignment: VkDeviceSize,
    pub pictureAccessGranularity: VkExtent2D,
    pub minCodedExtent: VkExtent2D,
    pub maxCodedExtent: VkExtent2D,
    pub maxDpbSlots: u32,
    pub maxActiveReferencePictures: u32,
    pub stdHeaderVersion: VkExtensionProperties,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoCodingControlInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkVideoCodingControlFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeAV1CapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxLevel: StdVideoAV1Level,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeAV1DpbSlotInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pStdReferenceInfo: *const StdVideoDecodeAV1ReferenceInfo,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeAV1InlineSessionParametersInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pStdSequenceHeader: *const StdVideoAV1SequenceHeader,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeAV1PictureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pStdPictureInfo: *const StdVideoDecodeAV1PictureInfo,
    pub referenceNameSlotIndices: [i32; VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR as usize],
    pub frameHeaderOffset: u32,
    pub tileCount: u32,
    pub pTileOffsets: *const u32,
    pub pTileSizes: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeAV1ProfileInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stdProfile: StdVideoAV1Profile,
    pub filmGrainSupport: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeAV1SessionParametersCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pStdSequenceHeader: *const StdVideoAV1SequenceHeader,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub flags: VkVideoDecodeCapabilityFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeH264CapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxLevelIdc: StdVideoH264LevelIdc,
    pub fieldOffsetGranularity: VkOffset2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeH264DpbSlotInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pStdReferenceInfo: *const StdVideoDecodeH264ReferenceInfo,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeH264InlineSessionParametersInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pStdSPS: *const StdVideoH264SequenceParameterSet,
    pub pStdPPS: *const StdVideoH264PictureParameterSet,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeH264PictureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pStdPictureInfo: *const StdVideoDecodeH264PictureInfo,
    pub sliceCount: u32,
    pub pSliceOffsets: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeH264ProfileInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stdProfileIdc: StdVideoH264ProfileIdc,
    pub pictureLayout: VkVideoDecodeH264PictureLayoutFlagBitsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeH264SessionParametersAddInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stdSPSCount: u32,
    pub pStdSPSs: *const StdVideoH264SequenceParameterSet,
    pub stdPPSCount: u32,
    pub pStdPPSs: *const StdVideoH264PictureParameterSet,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeH264SessionParametersCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub maxStdSPSCount: u32,
    pub maxStdPPSCount: u32,
    pub pParametersAddInfo: *const VkVideoDecodeH264SessionParametersAddInfoKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeH265CapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxLevelIdc: StdVideoH265LevelIdc,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeH265DpbSlotInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pStdReferenceInfo: *const StdVideoDecodeH265ReferenceInfo,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeH265InlineSessionParametersInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pStdVPS: *const StdVideoH265VideoParameterSet,
    pub pStdSPS: *const StdVideoH265SequenceParameterSet,
    pub pStdPPS: *const StdVideoH265PictureParameterSet,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeH265PictureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pStdPictureInfo: *const StdVideoDecodeH265PictureInfo,
    pub sliceSegmentCount: u32,
    pub pSliceSegmentOffsets: *const u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeH265ProfileInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stdProfileIdc: StdVideoH265ProfileIdc,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeH265SessionParametersAddInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stdVPSCount: u32,
    pub pStdVPSs: *const StdVideoH265VideoParameterSet,
    pub stdSPSCount: u32,
    pub pStdSPSs: *const StdVideoH265SequenceParameterSet,
    pub stdPPSCount: u32,
    pub pStdPPSs: *const StdVideoH265PictureParameterSet,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeH265SessionParametersCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub maxStdVPSCount: u32,
    pub maxStdSPSCount: u32,
    pub maxStdPPSCount: u32,
    pub pParametersAddInfo: *const VkVideoDecodeH265SessionParametersAddInfoKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkVideoDecodeFlagsKHR,
    pub srcBuffer: VkBuffer,
    pub srcBufferOffset: VkDeviceSize,
    pub srcBufferRange: VkDeviceSize,
    pub dstPictureResource: VkVideoPictureResourceInfoKHR,
    pub pSetupReferenceSlot: *const VkVideoReferenceSlotInfoKHR,
    pub referenceSlotCount: u32,
    pub pReferenceSlots: *const VkVideoReferenceSlotInfoKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeUsageInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub videoUsageHints: VkVideoDecodeUsageFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeVP9CapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxLevel: StdVideoVP9Level,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeVP9PictureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pStdPictureInfo: *const StdVideoDecodeVP9PictureInfo,
    pub referenceNameSlotIndices: [i32; VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR as usize],
    pub uncompressedHeaderOffset: u32,
    pub compressedHeaderOffset: u32,
    pub tilesOffset: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoDecodeVP9ProfileInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stdProfile: StdVideoVP9Profile,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeAV1CapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub flags: VkVideoEncodeAV1CapabilityFlagsKHR,
    pub maxLevel: StdVideoAV1Level,
    pub codedPictureAlignment: VkExtent2D,
    pub maxTiles: VkExtent2D,
    pub minTileSize: VkExtent2D,
    pub maxTileSize: VkExtent2D,
    pub superblockSizes: VkVideoEncodeAV1SuperblockSizeFlagsKHR,
    pub maxSingleReferenceCount: u32,
    pub singleReferenceNameMask: u32,
    pub maxUnidirectionalCompoundReferenceCount: u32,
    pub maxUnidirectionalCompoundGroup1ReferenceCount: u32,
    pub unidirectionalCompoundReferenceNameMask: u32,
    pub maxBidirectionalCompoundReferenceCount: u32,
    pub maxBidirectionalCompoundGroup1ReferenceCount: u32,
    pub maxBidirectionalCompoundGroup2ReferenceCount: u32,
    pub bidirectionalCompoundReferenceNameMask: u32,
    pub maxTemporalLayerCount: u32,
    pub maxSpatialLayerCount: u32,
    pub maxOperatingPoints: u32,
    pub minQIndex: u32,
    pub maxQIndex: u32,
    pub prefersGopRemainingFrames: VkBool32,
    pub requiresGopRemainingFrames: VkBool32,
    pub stdSyntaxFlags: VkVideoEncodeAV1StdFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeAV1DpbSlotInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pStdReferenceInfo: *const StdVideoEncodeAV1ReferenceInfo,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeAV1FrameSizeKHR {
    pub intraFrameSize: u32,
    pub predictiveFrameSize: u32,
    pub bipredictiveFrameSize: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeAV1GopRemainingFrameInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub useGopRemainingFrames: VkBool32,
    pub gopRemainingIntra: u32,
    pub gopRemainingPredictive: u32,
    pub gopRemainingBipredictive: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeAV1PictureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub predictionMode: VkVideoEncodeAV1PredictionModeKHR,
    pub rateControlGroup: VkVideoEncodeAV1RateControlGroupKHR,
    pub constantQIndex: u32,
    pub pStdPictureInfo: *const StdVideoEncodeAV1PictureInfo,
    pub referenceNameSlotIndices: [i32; VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR as usize],
    pub primaryReferenceCdfOnly: VkBool32,
    pub generateObuExtensionHeader: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeAV1ProfileInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stdProfile: StdVideoAV1Profile,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeAV1QIndexKHR {
    pub intraQIndex: u32,
    pub predictiveQIndex: u32,
    pub bipredictiveQIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeAV1QualityLevelPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub preferredRateControlFlags: VkVideoEncodeAV1RateControlFlagsKHR,
    pub preferredGopFrameCount: u32,
    pub preferredKeyFramePeriod: u32,
    pub preferredConsecutiveBipredictiveFrameCount: u32,
    pub preferredTemporalLayerCount: u32,
    pub preferredConstantQIndex: VkVideoEncodeAV1QIndexKHR,
    pub preferredMaxSingleReferenceCount: u32,
    pub preferredSingleReferenceNameMask: u32,
    pub preferredMaxUnidirectionalCompoundReferenceCount: u32,
    pub preferredMaxUnidirectionalCompoundGroup1ReferenceCount: u32,
    pub preferredUnidirectionalCompoundReferenceNameMask: u32,
    pub preferredMaxBidirectionalCompoundReferenceCount: u32,
    pub preferredMaxBidirectionalCompoundGroup1ReferenceCount: u32,
    pub preferredMaxBidirectionalCompoundGroup2ReferenceCount: u32,
    pub preferredBidirectionalCompoundReferenceNameMask: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeAV1QuantizationMapCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub minQIndexDelta: i32,
    pub maxQIndexDelta: i32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeAV1RateControlInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkVideoEncodeAV1RateControlFlagsKHR,
    pub gopFrameCount: u32,
    pub keyFramePeriod: u32,
    pub consecutiveBipredictiveFrameCount: u32,
    pub temporalLayerCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeAV1RateControlLayerInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub useMinQIndex: VkBool32,
    pub minQIndex: VkVideoEncodeAV1QIndexKHR,
    pub useMaxQIndex: VkBool32,
    pub maxQIndex: VkVideoEncodeAV1QIndexKHR,
    pub useMaxFrameSize: VkBool32,
    pub maxFrameSize: VkVideoEncodeAV1FrameSizeKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeAV1SessionCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub useMaxLevel: VkBool32,
    pub maxLevel: StdVideoAV1Level,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeAV1SessionParametersCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pStdSequenceHeader: *const StdVideoAV1SequenceHeader,
    pub pStdDecoderModelInfo: *const StdVideoEncodeAV1DecoderModelInfo,
    pub stdOperatingPointCount: u32,
    pub pStdOperatingPoints: *const StdVideoEncodeAV1OperatingPointInfo,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub flags: VkVideoEncodeCapabilityFlagsKHR,
    pub rateControlModes: VkVideoEncodeRateControlModeFlagsKHR,
    pub maxRateControlLayers: u32,
    pub maxBitrate: u64,
    pub maxQualityLevels: u32,
    pub encodeInputPictureGranularity: VkExtent2D,
    pub supportedEncodeFeedbackFlags: VkVideoEncodeFeedbackFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264CapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub flags: VkVideoEncodeH264CapabilityFlagsKHR,
    pub maxLevelIdc: StdVideoH264LevelIdc,
    pub maxSliceCount: u32,
    pub maxPPictureL0ReferenceCount: u32,
    pub maxBPictureL0ReferenceCount: u32,
    pub maxL1ReferenceCount: u32,
    pub maxTemporalLayerCount: u32,
    pub expectDyadicTemporalLayerPattern: VkBool32,
    pub minQp: i32,
    pub maxQp: i32,
    pub prefersGopRemainingFrames: VkBool32,
    pub requiresGopRemainingFrames: VkBool32,
    pub stdSyntaxFlags: VkVideoEncodeH264StdFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264DpbSlotInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pStdReferenceInfo: *const StdVideoEncodeH264ReferenceInfo,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264FrameSizeKHR {
    pub frameISize: u32,
    pub framePSize: u32,
    pub frameBSize: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264GopRemainingFrameInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub useGopRemainingFrames: VkBool32,
    pub gopRemainingI: u32,
    pub gopRemainingP: u32,
    pub gopRemainingB: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264NaluSliceInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub constantQp: i32,
    pub pStdSliceHeader: *const StdVideoEncodeH264SliceHeader,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264PictureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub naluSliceEntryCount: u32,
    pub pNaluSliceEntries: *const VkVideoEncodeH264NaluSliceInfoKHR,
    pub pStdPictureInfo: *const StdVideoEncodeH264PictureInfo,
    pub generatePrefixNalu: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264ProfileInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stdProfileIdc: StdVideoH264ProfileIdc,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264QpKHR {
    pub qpI: i32,
    pub qpP: i32,
    pub qpB: i32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264QualityLevelPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub preferredRateControlFlags: VkVideoEncodeH264RateControlFlagsKHR,
    pub preferredGopFrameCount: u32,
    pub preferredIdrPeriod: u32,
    pub preferredConsecutiveBFrameCount: u32,
    pub preferredTemporalLayerCount: u32,
    pub preferredConstantQp: VkVideoEncodeH264QpKHR,
    pub preferredMaxL0ReferenceCount: u32,
    pub preferredMaxL1ReferenceCount: u32,
    pub preferredStdEntropyCodingModeFlag: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264QuantizationMapCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub minQpDelta: i32,
    pub maxQpDelta: i32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264RateControlInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkVideoEncodeH264RateControlFlagsKHR,
    pub gopFrameCount: u32,
    pub idrPeriod: u32,
    pub consecutiveBFrameCount: u32,
    pub temporalLayerCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264RateControlLayerInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub useMinQp: VkBool32,
    pub minQp: VkVideoEncodeH264QpKHR,
    pub useMaxQp: VkBool32,
    pub maxQp: VkVideoEncodeH264QpKHR,
    pub useMaxFrameSize: VkBool32,
    pub maxFrameSize: VkVideoEncodeH264FrameSizeKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264SessionCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub useMaxLevelIdc: VkBool32,
    pub maxLevelIdc: StdVideoH264LevelIdc,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264SessionParametersAddInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stdSPSCount: u32,
    pub pStdSPSs: *const StdVideoH264SequenceParameterSet,
    pub stdPPSCount: u32,
    pub pStdPPSs: *const StdVideoH264PictureParameterSet,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264SessionParametersCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub maxStdSPSCount: u32,
    pub maxStdPPSCount: u32,
    pub pParametersAddInfo: *const VkVideoEncodeH264SessionParametersAddInfoKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264SessionParametersFeedbackInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub hasStdSPSOverrides: VkBool32,
    pub hasStdPPSOverrides: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH264SessionParametersGetInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub writeStdSPS: VkBool32,
    pub writeStdPPS: VkBool32,
    pub stdSPSId: u32,
    pub stdPPSId: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265CapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub flags: VkVideoEncodeH265CapabilityFlagsKHR,
    pub maxLevelIdc: StdVideoH265LevelIdc,
    pub maxSliceSegmentCount: u32,
    pub maxTiles: VkExtent2D,
    pub ctbSizes: VkVideoEncodeH265CtbSizeFlagsKHR,
    pub transformBlockSizes: VkVideoEncodeH265TransformBlockSizeFlagsKHR,
    pub maxPPictureL0ReferenceCount: u32,
    pub maxBPictureL0ReferenceCount: u32,
    pub maxL1ReferenceCount: u32,
    pub maxSubLayerCount: u32,
    pub expectDyadicTemporalSubLayerPattern: VkBool32,
    pub minQp: i32,
    pub maxQp: i32,
    pub prefersGopRemainingFrames: VkBool32,
    pub requiresGopRemainingFrames: VkBool32,
    pub stdSyntaxFlags: VkVideoEncodeH265StdFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265DpbSlotInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub pStdReferenceInfo: *const StdVideoEncodeH265ReferenceInfo,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265FrameSizeKHR {
    pub frameISize: u32,
    pub framePSize: u32,
    pub frameBSize: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265GopRemainingFrameInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub useGopRemainingFrames: VkBool32,
    pub gopRemainingI: u32,
    pub gopRemainingP: u32,
    pub gopRemainingB: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265NaluSliceSegmentInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub constantQp: i32,
    pub pStdSliceSegmentHeader: *const StdVideoEncodeH265SliceSegmentHeader,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265PictureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub naluSliceSegmentEntryCount: u32,
    pub pNaluSliceSegmentEntries: *const VkVideoEncodeH265NaluSliceSegmentInfoKHR,
    pub pStdPictureInfo: *const StdVideoEncodeH265PictureInfo,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265ProfileInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stdProfileIdc: StdVideoH265ProfileIdc,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265QpKHR {
    pub qpI: i32,
    pub qpP: i32,
    pub qpB: i32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265QualityLevelPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub preferredRateControlFlags: VkVideoEncodeH265RateControlFlagsKHR,
    pub preferredGopFrameCount: u32,
    pub preferredIdrPeriod: u32,
    pub preferredConsecutiveBFrameCount: u32,
    pub preferredSubLayerCount: u32,
    pub preferredConstantQp: VkVideoEncodeH265QpKHR,
    pub preferredMaxL0ReferenceCount: u32,
    pub preferredMaxL1ReferenceCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265QuantizationMapCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub minQpDelta: i32,
    pub maxQpDelta: i32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265RateControlInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkVideoEncodeH265RateControlFlagsKHR,
    pub gopFrameCount: u32,
    pub idrPeriod: u32,
    pub consecutiveBFrameCount: u32,
    pub subLayerCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265RateControlLayerInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub useMinQp: VkBool32,
    pub minQp: VkVideoEncodeH265QpKHR,
    pub useMaxQp: VkBool32,
    pub maxQp: VkVideoEncodeH265QpKHR,
    pub useMaxFrameSize: VkBool32,
    pub maxFrameSize: VkVideoEncodeH265FrameSizeKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265SessionCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub useMaxLevelIdc: VkBool32,
    pub maxLevelIdc: StdVideoH265LevelIdc,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265SessionParametersAddInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub stdVPSCount: u32,
    pub pStdVPSs: *const StdVideoH265VideoParameterSet,
    pub stdSPSCount: u32,
    pub pStdSPSs: *const StdVideoH265SequenceParameterSet,
    pub stdPPSCount: u32,
    pub pStdPPSs: *const StdVideoH265PictureParameterSet,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265SessionParametersCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub maxStdVPSCount: u32,
    pub maxStdSPSCount: u32,
    pub maxStdPPSCount: u32,
    pub pParametersAddInfo: *const VkVideoEncodeH265SessionParametersAddInfoKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265SessionParametersFeedbackInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub hasStdVPSOverrides: VkBool32,
    pub hasStdSPSOverrides: VkBool32,
    pub hasStdPPSOverrides: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeH265SessionParametersGetInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub writeStdVPS: VkBool32,
    pub writeStdSPS: VkBool32,
    pub writeStdPPS: VkBool32,
    pub stdVPSId: u32,
    pub stdSPSId: u32,
    pub stdPPSId: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkVideoEncodeFlagsKHR,
    pub dstBuffer: VkBuffer,
    pub dstBufferOffset: VkDeviceSize,
    pub dstBufferRange: VkDeviceSize,
    pub srcPictureResource: VkVideoPictureResourceInfoKHR,
    pub pSetupReferenceSlot: *const VkVideoReferenceSlotInfoKHR,
    pub referenceSlotCount: u32,
    pub pReferenceSlots: *const VkVideoReferenceSlotInfoKHR,
    pub precedingExternallyEncodedBytes: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeIntraRefreshCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub intraRefreshModes: VkVideoEncodeIntraRefreshModeFlagsKHR,
    pub maxIntraRefreshCycleDuration: u32,
    pub maxIntraRefreshActiveReferencePictures: u32,
    pub partitionIndependentIntraRefreshRegions: VkBool32,
    pub nonRectangularIntraRefreshRegions: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeIntraRefreshInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub intraRefreshCycleDuration: u32,
    pub intraRefreshIndex: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeProfileRgbConversionInfoVALVE {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub performEncodeRgbConversion: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeQualityLevelInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub qualityLevel: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeQualityLevelPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub preferredRateControlMode: VkVideoEncodeRateControlModeFlagBitsKHR,
    pub preferredRateControlLayerCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeQuantizationMapCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub maxQuantizationMapExtent: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeQuantizationMapInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub quantizationMap: VkImageView,
    pub quantizationMapExtent: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub quantizationMapTexelSize: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeRateControlInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkVideoEncodeRateControlFlagsKHR,
    pub rateControlMode: VkVideoEncodeRateControlModeFlagBitsKHR,
    pub layerCount: u32,
    pub pLayers: *const VkVideoEncodeRateControlLayerInfoKHR,
    pub virtualBufferSizeInMs: u32,
    pub initialVirtualBufferSizeInMs: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeRateControlLayerInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub averageBitrate: u64,
    pub maxBitrate: u64,
    pub frameRateNumerator: u32,
    pub frameRateDenominator: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeRgbConversionCapabilitiesVALVE {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub rgbModels: VkVideoEncodeRgbModelConversionFlagsVALVE,
    pub rgbRanges: VkVideoEncodeRgbRangeCompressionFlagsVALVE,
    pub xChromaOffsets: VkVideoEncodeRgbChromaOffsetFlagsVALVE,
    pub yChromaOffsets: VkVideoEncodeRgbChromaOffsetFlagsVALVE,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub intraRefreshMode: VkVideoEncodeIntraRefreshModeFlagBitsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeSessionParametersFeedbackInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub hasOverrides: VkBool32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeSessionParametersGetInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub videoSessionParameters: VkVideoSessionParametersKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeSessionRgbConversionCreateInfoVALVE {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub rgbModel: VkVideoEncodeRgbModelConversionFlagBitsVALVE,
    pub rgbRange: VkVideoEncodeRgbRangeCompressionFlagBitsVALVE,
    pub xChromaOffset: VkVideoEncodeRgbChromaOffsetFlagBitsVALVE,
    pub yChromaOffset: VkVideoEncodeRgbChromaOffsetFlagBitsVALVE,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEncodeUsageInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub videoUsageHints: VkVideoEncodeUsageFlagsKHR,
    pub videoContentHints: VkVideoEncodeContentFlagsKHR,
    pub tuningMode: VkVideoEncodeTuningModeKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoEndCodingInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkVideoEndCodingFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoFormatAV1QuantizationMapPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub compatibleSuperblockSizes: VkVideoEncodeAV1SuperblockSizeFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoFormatH265QuantizationMapPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub compatibleCtbSizes: VkVideoEncodeH265CtbSizeFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoFormatPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub format: VkFormat,
    pub componentMapping: VkComponentMapping,
    pub imageCreateFlags: VkImageCreateFlags,
    pub imageType: VkImageType,
    pub imageTiling: VkImageTiling,
    pub imageUsageFlags: VkImageUsageFlags,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoFormatQuantizationMapPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub quantizationMapTexelSize: VkExtent2D,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoInlineQueryInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub queryPool: VkQueryPool,
    pub firstQuery: u32,
    pub queryCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoPictureResourceInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub codedOffset: VkOffset2D,
    pub codedExtent: VkExtent2D,
    pub baseArrayLayer: u32,
    pub imageViewBinding: VkImageView,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoProfileInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub videoCodecOperation: VkVideoCodecOperationFlagBitsKHR,
    pub chromaSubsampling: VkVideoChromaSubsamplingFlagsKHR,
    pub lumaBitDepth: VkVideoComponentBitDepthFlagsKHR,
    pub chromaBitDepth: VkVideoComponentBitDepthFlagsKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoProfileListInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub profileCount: u32,
    pub pProfiles: *const VkVideoProfileInfoKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoReferenceIntraRefreshInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub dirtyIntraRefreshRegions: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoReferenceSlotInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub slotIndex: i32,
    pub pPictureResource: *const VkVideoPictureResourceInfoKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoSessionCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub queueFamilyIndex: u32,
    pub flags: VkVideoSessionCreateFlagsKHR,
    pub pVideoProfile: *const VkVideoProfileInfoKHR,
    pub pictureFormat: VkFormat,
    pub maxCodedExtent: VkExtent2D,
    pub referencePictureFormat: VkFormat,
    pub maxDpbSlots: u32,
    pub maxActiveReferencePictures: u32,
    pub pStdHeaderVersion: *const VkExtensionProperties,
}

#[repr(C)]
pub struct VkVideoSessionKHR_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoSessionMemoryRequirementsKHR {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub memoryBindIndex: u32,
    pub memoryRequirements: VkMemoryRequirements,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoSessionParametersCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub flags: VkVideoSessionParametersCreateFlagsKHR,
    pub videoSessionParametersTemplate: VkVideoSessionParametersKHR,
    pub videoSession: VkVideoSessionKHR,
}

#[repr(C)]
pub struct VkVideoSessionParametersKHR_T {
    _data: (),
    _marker: PhantomData<(*mut u8, PhantomPinned)>,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkVideoSessionParametersUpdateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub updateSequenceCount: u32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkViewport {
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    pub minDepth: f32,
    pub maxDepth: f32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkViewportSwizzleNV {
    pub x: VkViewportCoordinateSwizzleNV,
    pub y: VkViewportCoordinateSwizzleNV,
    pub z: VkViewportCoordinateSwizzleNV,
    pub w: VkViewportCoordinateSwizzleNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkViewportWScalingNV {
    pub xcoeff: f32,
    pub ycoeff: f32,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkWriteDescriptorSet {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub dstSet: VkDescriptorSet,
    pub dstBinding: u32,
    pub dstArrayElement: u32,
    pub descriptorCount: u32,
    pub descriptorType: VkDescriptorType,
    pub pImageInfo: *const VkDescriptorImageInfo,
    pub pBufferInfo: *const VkDescriptorBufferInfo,
    pub pTexelBufferView: *const VkBufferView,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkWriteDescriptorSetAccelerationStructureKHR {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub accelerationStructureCount: u32,
    pub pAccelerationStructures: *const VkAccelerationStructureKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkWriteDescriptorSetAccelerationStructureNV {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub accelerationStructureCount: u32,
    pub pAccelerationStructures: *const VkAccelerationStructureNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkWriteDescriptorSetInlineUniformBlock {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub dataSize: u32,
    pub pData: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkWriteDescriptorSetPartitionedAccelerationStructureNV {
    pub sType: VkStructureType,
    pub pNext: *mut c_void,
    pub accelerationStructureCount: u32,
    pub pAccelerationStructures: *const VkDeviceAddress,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkWriteDescriptorSetTensorARM {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub tensorViewCount: u32,
    pub pTensorViews: *const VkTensorViewARM,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkWriteIndirectExecutionSetPipelineEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub index: u32,
    pub pipeline: VkPipeline,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkWriteIndirectExecutionSetShaderEXT {
    pub sType: VkStructureType,
    pub pNext: *const c_void,
    pub index: u32,
    pub shader: VkShaderEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct VkXYColorEXT {
    pub x: f32,
    pub y: f32,
}

pub const VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR: VkAccelerationStructureBuildTypeKHR = 1;
pub const VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR: VkAccelerationStructureBuildTypeKHR = 0;
pub const VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR: VkAccelerationStructureBuildTypeKHR = 2;
pub const VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR: VkAccelerationStructureCompatibilityKHR = 0;
pub const VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR: VkAccelerationStructureCompatibilityKHR = 1;
pub const VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkAccelerationStructureCreateFlagBitsKHR = 1 << 3;
pub const VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: VkAccelerationStructureCreateFlagBitsKHR = 1 << 0;
pub const VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV: VkAccelerationStructureCreateFlagBitsKHR = 1 << 2;
pub const VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV: VkAccelerationStructureMemoryRequirementsTypeNV = 1;
pub const VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV: VkAccelerationStructureMemoryRequirementsTypeNV = 0;
pub const VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV: VkAccelerationStructureMemoryRequirementsTypeNV = 2;
pub const VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV: VkAccelerationStructureMotionInstanceTypeNV = 1;
pub const VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV: VkAccelerationStructureMotionInstanceTypeNV = 2;
pub const VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV: VkAccelerationStructureMotionInstanceTypeNV = 0;
pub const VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR: VkAccelerationStructureTypeKHR = 1;
pub const VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV: VkAccelerationStructureTypeKHR = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR;
pub const VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR: VkAccelerationStructureTypeKHR = 2;
pub const VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR: VkAccelerationStructureTypeKHR = 0;
pub const VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV: VkAccelerationStructureTypeKHR = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR;
pub const VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR: VkAccessFlagBits2 = 1 << 21;
pub const VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV: VkAccessFlagBits2 = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR;
pub const VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR: VkAccessFlagBits2 = 1 << 22;
pub const VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV: VkAccessFlagBits2 = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR;
pub const VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT: VkAccessFlagBits2 = 1 << 7;
pub const VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT;
pub const VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT: VkAccessFlagBits2 = 1 << 19;
pub const VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT: VkAccessFlagBits2 = 1 << 8;
pub const VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
pub const VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 17;
pub const VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV: VkAccessFlagBits2 = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT;
pub const VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT: VkAccessFlagBits2 = 1 << 18;
pub const VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV: VkAccessFlagBits2 = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT;
pub const VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 20;
pub const VK_ACCESS_2_DATA_GRAPH_READ_BIT_ARM: VkAccessFlagBits2 = 1 << 47;
pub const VK_ACCESS_2_DATA_GRAPH_WRITE_BIT_ARM: VkAccessFlagBits2 = 1 << 48;
pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT: VkAccessFlagBits2 = 1 << 9;
pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: VkAccessFlagBits2 = 1 << 10;
pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
pub const VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 41;
pub const VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 24;
pub const VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits2 = 1 << 23;
pub const VK_ACCESS_2_HOST_READ_BIT: VkAccessFlagBits2 = 1 << 13;
pub const VK_ACCESS_2_HOST_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_HOST_READ_BIT;
pub const VK_ACCESS_2_HOST_WRITE_BIT: VkAccessFlagBits2 = 1 << 14;
pub const VK_ACCESS_2_HOST_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_HOST_WRITE_BIT;
pub const VK_ACCESS_2_INDEX_READ_BIT: VkAccessFlagBits2 = 1 << 1;
pub const VK_ACCESS_2_INDEX_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_INDEX_READ_BIT;
pub const VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT: VkAccessFlagBits2 = 1 << 0;
pub const VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT;
pub const VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT: VkAccessFlagBits2 = 1 << 4;
pub const VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT;
pub const VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI: VkAccessFlagBits2 = 1 << 39;
pub const VK_ACCESS_2_MEMORY_DECOMPRESSION_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 55;
pub const VK_ACCESS_2_MEMORY_DECOMPRESSION_WRITE_BIT_EXT: VkAccessFlagBits2 = 1 << 56;
pub const VK_ACCESS_2_MEMORY_READ_BIT: VkAccessFlagBits2 = 1 << 15;
pub const VK_ACCESS_2_MEMORY_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_MEMORY_READ_BIT;
pub const VK_ACCESS_2_MEMORY_WRITE_BIT: VkAccessFlagBits2 = 1 << 16;
pub const VK_ACCESS_2_MEMORY_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_MEMORY_WRITE_BIT;
pub const VK_ACCESS_2_MICROMAP_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 44;
pub const VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT: VkAccessFlagBits2 = 1 << 45;
pub const VK_ACCESS_2_NONE: VkAccessFlagBits2 = 0;
pub const VK_ACCESS_2_NONE_KHR: VkAccessFlagBits2 = VK_ACCESS_2_NONE;
pub const VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV: VkAccessFlagBits2 = 1 << 42;
pub const VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV: VkAccessFlagBits2 = 1 << 43;
pub const VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR: VkAccessFlagBits2 = 1 << 40;
pub const VK_ACCESS_2_SHADER_READ_BIT: VkAccessFlagBits2 = 1 << 5;
pub const VK_ACCESS_2_SHADER_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_SHADER_READ_BIT;
pub const VK_ACCESS_2_SHADER_SAMPLED_READ_BIT: VkAccessFlagBits2 = 1 << 32;
pub const VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
pub const VK_ACCESS_2_SHADER_STORAGE_READ_BIT: VkAccessFlagBits2 = 1 << 33;
pub const VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_SHADER_STORAGE_READ_BIT;
pub const VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT: VkAccessFlagBits2 = 1 << 34;
pub const VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT;
pub const VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM: VkAccessFlagBits2 = 1 << 51;
pub const VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM: VkAccessFlagBits2 = 1 << 52;
pub const VK_ACCESS_2_SHADER_WRITE_BIT: VkAccessFlagBits2 = 1 << 6;
pub const VK_ACCESS_2_SHADER_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_SHADER_WRITE_BIT;
pub const VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV: VkAccessFlagBits2 = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR;
pub const VK_ACCESS_2_TRANSFER_READ_BIT: VkAccessFlagBits2 = 1 << 11;
pub const VK_ACCESS_2_TRANSFER_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_TRANSFER_READ_BIT;
pub const VK_ACCESS_2_TRANSFER_WRITE_BIT: VkAccessFlagBits2 = 1 << 12;
pub const VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_TRANSFER_WRITE_BIT;
pub const VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 26;
pub const VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT: VkAccessFlagBits2 = 1 << 27;
pub const VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT: VkAccessFlagBits2 = 1 << 25;
pub const VK_ACCESS_2_UNIFORM_READ_BIT: VkAccessFlagBits2 = 1 << 3;
pub const VK_ACCESS_2_UNIFORM_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_UNIFORM_READ_BIT;
pub const VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT: VkAccessFlagBits2 = 1 << 2;
pub const VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT;
pub const VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR: VkAccessFlagBits2 = 1 << 35;
pub const VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR: VkAccessFlagBits2 = 1 << 36;
pub const VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR: VkAccessFlagBits2 = 1 << 37;
pub const VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR: VkAccessFlagBits2 = 1 << 38;
pub const VK_ACCESS_3_NONE_KHR: VkAccessFlagBits3KHR = 0;
pub const VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR: VkAccessFlagBits = 1 << 21;
pub const VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV: VkAccessFlagBits = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;
pub const VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR: VkAccessFlagBits = 1 << 22;
pub const VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV: VkAccessFlagBits = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR;
pub const VK_ACCESS_COLOR_ATTACHMENT_READ_BIT: VkAccessFlagBits = 1 << 7;
pub const VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT: VkAccessFlagBits = 1 << 19;
pub const VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT: VkAccessFlagBits = 1 << 8;
pub const VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT: VkAccessFlagBits = 1 << 17;
pub const VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV: VkAccessFlagBits = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT;
pub const VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT: VkAccessFlagBits = 1 << 18;
pub const VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV: VkAccessFlagBits = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT;
pub const VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT: VkAccessFlagBits = 1 << 20;
pub const VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT: VkAccessFlagBits = 1 << 9;
pub const VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: VkAccessFlagBits = 1 << 10;
pub const VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT: VkAccessFlagBits = 1 << 24;
pub const VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits = 1 << 23;
pub const VK_ACCESS_HOST_READ_BIT: VkAccessFlagBits = 1 << 13;
pub const VK_ACCESS_HOST_WRITE_BIT: VkAccessFlagBits = 1 << 14;
pub const VK_ACCESS_INDEX_READ_BIT: VkAccessFlagBits = 1 << 1;
pub const VK_ACCESS_INDIRECT_COMMAND_READ_BIT: VkAccessFlagBits = 1 << 0;
pub const VK_ACCESS_INPUT_ATTACHMENT_READ_BIT: VkAccessFlagBits = 1 << 4;
pub const VK_ACCESS_MEMORY_READ_BIT: VkAccessFlagBits = 1 << 15;
pub const VK_ACCESS_MEMORY_WRITE_BIT: VkAccessFlagBits = 1 << 16;
pub const VK_ACCESS_NONE: VkAccessFlagBits = 0;
pub const VK_ACCESS_NONE_KHR: VkAccessFlagBits = VK_ACCESS_NONE;
pub const VK_ACCESS_SHADER_READ_BIT: VkAccessFlagBits = 1 << 5;
pub const VK_ACCESS_SHADER_WRITE_BIT: VkAccessFlagBits = 1 << 6;
pub const VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV: VkAccessFlagBits = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR;
pub const VK_ACCESS_TRANSFER_READ_BIT: VkAccessFlagBits = 1 << 11;
pub const VK_ACCESS_TRANSFER_WRITE_BIT: VkAccessFlagBits = 1 << 12;
pub const VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT: VkAccessFlagBits = 1 << 26;
pub const VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT: VkAccessFlagBits = 1 << 27;
pub const VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT: VkAccessFlagBits = 1 << 25;
pub const VK_ACCESS_UNIFORM_READ_BIT: VkAccessFlagBits = 1 << 3;
pub const VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT: VkAccessFlagBits = 1 << 2;
pub const VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR: VkAddressCopyFlagBitsKHR = 1 << 0;
pub const VK_ADDRESS_COPY_PROTECTED_BIT_KHR: VkAddressCopyFlagBitsKHR = 1 << 2;
pub const VK_ADDRESS_COPY_SPARSE_BIT_KHR: VkAddressCopyFlagBitsKHR = 1 << 1;
pub const VK_AMD_ANTI_LAG_EXTENSION_NAME: &CStr = c"VK_AMD_anti_lag";
pub const VK_AMD_ANTI_LAG_SPEC_VERSION: u32 = 1;
pub const VK_AMD_BUFFER_MARKER_EXTENSION_NAME: &CStr = c"VK_AMD_buffer_marker";
pub const VK_AMD_BUFFER_MARKER_SPEC_VERSION: u32 = 1;
pub const VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME: &CStr = c"VK_AMD_device_coherent_memory";
pub const VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION: u32 = 1;
pub const VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME: &CStr = c"VK_AMD_display_native_hdr";
pub const VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION: u32 = 1;
pub const VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME: &CStr = c"VK_AMD_draw_indirect_count";
pub const VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION: u32 = 2;
pub const VK_AMD_GCN_SHADER_EXTENSION_NAME: &CStr = c"VK_AMD_gcn_shader";
pub const VK_AMD_GCN_SHADER_SPEC_VERSION: u32 = 1;
pub const VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME: &CStr = c"VK_AMD_gpu_shader_half_float";
pub const VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION: u32 = 2;
pub const VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME: &CStr = c"VK_AMD_gpu_shader_int16";
pub const VK_AMD_GPU_SHADER_INT16_SPEC_VERSION: u32 = 2;
pub const VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME: &CStr = c"VK_AMD_memory_overallocation_behavior";
pub const VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION: u32 = 1;
pub const VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME: &CStr = c"VK_AMD_mixed_attachment_samples";
pub const VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION: u32 = 1;
pub const VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME: &CStr = c"VK_AMD_negative_viewport_height";
pub const VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION: u32 = 1;
pub const VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME: &CStr = c"VK_AMD_pipeline_compiler_control";
pub const VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION: u32 = 1;
pub const VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME: &CStr = c"VK_AMD_rasterization_order";
pub const VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION: u32 = 1;
pub const VK_AMD_SHADER_BALLOT_EXTENSION_NAME: &CStr = c"VK_AMD_shader_ballot";
pub const VK_AMD_SHADER_BALLOT_SPEC_VERSION: u32 = 1;
pub const VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME: &CStr = c"VK_AMD_shader_core_properties2";
pub const VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION: u32 = 1;
pub const VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_AMD_shader_core_properties";
pub const VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION: u32 = 2;
pub const VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_EXTENSION_NAME: &CStr = c"VK_AMD_shader_early_and_late_fragment_tests";
pub const VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION: u32 = 1;
pub const VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME: &CStr = c"VK_AMD_shader_explicit_vertex_parameter";
pub const VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION: u32 = 1;
pub const VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME: &CStr = c"VK_AMD_shader_fragment_mask";
pub const VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION: u32 = 1;
pub const VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME: &CStr = c"VK_AMD_shader_image_load_store_lod";
pub const VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION: u32 = 1;
pub const VK_AMD_SHADER_INFO_EXTENSION_NAME: &CStr = c"VK_AMD_shader_info";
pub const VK_AMD_SHADER_INFO_SPEC_VERSION: u32 = 1;
pub const VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME: &CStr = c"VK_AMD_shader_trinary_minmax";
pub const VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION: u32 = 1;
pub const VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME: &CStr = c"VK_AMD_texture_gather_bias_lod";
pub const VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION: u32 = 1;
pub const VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD: VkAntiLagModeAMD = 0;
pub const VK_ANTI_LAG_MODE_OFF_AMD: VkAntiLagModeAMD = 2;
pub const VK_ANTI_LAG_MODE_ON_AMD: VkAntiLagModeAMD = 1;
pub const VK_ANTI_LAG_STAGE_INPUT_AMD: VkAntiLagStageAMD = 0;
pub const VK_ANTI_LAG_STAGE_PRESENT_AMD: VkAntiLagStageAMD = 1;
pub const VK_API_VERSION_1_0: u32 = VK_MAKE_API_VERSION(0, 1, 0, 0);
pub const VK_API_VERSION_1_1: u32 = VK_MAKE_API_VERSION(0, 1, 1, 0);
pub const VK_API_VERSION_1_2: u32 = VK_MAKE_API_VERSION(0, 1, 2, 0);
pub const VK_API_VERSION_1_3: u32 = VK_MAKE_API_VERSION(0, 1, 3, 0);
pub const VK_API_VERSION_1_4: u32 = VK_MAKE_API_VERSION(0, 1, 4, 0);
pub const VK_ARM_DATA_GRAPH_EXTENSION_NAME: &CStr = c"VK_ARM_data_graph";
pub const VK_ARM_DATA_GRAPH_SPEC_VERSION: u32 = 1;
pub const VK_ARM_FORMAT_PACK_EXTENSION_NAME: &CStr = c"VK_ARM_format_pack";
pub const VK_ARM_FORMAT_PACK_SPEC_VERSION: u32 = 1;
pub const VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_EXTENSION_NAME: &CStr = c"VK_ARM_performance_counters_by_region";
pub const VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_SPEC_VERSION: u32 = 1;
pub const VK_ARM_PIPELINE_OPACITY_MICROMAP_EXTENSION_NAME: &CStr = c"VK_ARM_pipeline_opacity_micromap";
pub const VK_ARM_PIPELINE_OPACITY_MICROMAP_SPEC_VERSION: u32 = 1;
pub const VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME: &CStr = c"VK_ARM_rasterization_order_attachment_access";
pub const VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION: u32 = 1;
pub const VK_ARM_RENDER_PASS_STRIPED_EXTENSION_NAME: &CStr = c"VK_ARM_render_pass_striped";
pub const VK_ARM_RENDER_PASS_STRIPED_SPEC_VERSION: u32 = 1;
pub const VK_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME: &CStr = c"VK_ARM_scheduling_controls";
pub const VK_ARM_SCHEDULING_CONTROLS_SPEC_VERSION: u32 = 1;
pub const VK_ARM_SHADER_CORE_BUILTINS_EXTENSION_NAME: &CStr = c"VK_ARM_shader_core_builtins";
pub const VK_ARM_SHADER_CORE_BUILTINS_SPEC_VERSION: u32 = 2;
pub const VK_ARM_SHADER_CORE_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_ARM_shader_core_properties";
pub const VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION: u32 = 1;
pub const VK_ARM_TENSORS_EXTENSION_NAME: &CStr = c"VK_ARM_tensors";
pub const VK_ARM_TENSORS_SPEC_VERSION: u32 = 1;
pub const VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT: VkAttachmentDescriptionFlagBits = 1 << 0;
pub const VK_ATTACHMENT_DESCRIPTION_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR: VkAttachmentDescriptionFlagBits = 1 << 2;
pub const VK_ATTACHMENT_DESCRIPTION_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR: VkAttachmentDescriptionFlagBits = 1 << 1;
pub const VK_ATTACHMENT_LOAD_OP_CLEAR: VkAttachmentLoadOp = 1;
pub const VK_ATTACHMENT_LOAD_OP_DONT_CARE: VkAttachmentLoadOp = 2;
pub const VK_ATTACHMENT_LOAD_OP_LOAD: VkAttachmentLoadOp = 0;
pub const VK_ATTACHMENT_LOAD_OP_NONE: VkAttachmentLoadOp = 1000400000;
pub const VK_ATTACHMENT_LOAD_OP_NONE_EXT: VkAttachmentLoadOp = VK_ATTACHMENT_LOAD_OP_NONE;
pub const VK_ATTACHMENT_LOAD_OP_NONE_KHR: VkAttachmentLoadOp = VK_ATTACHMENT_LOAD_OP_NONE;
pub const VK_ATTACHMENT_STORE_OP_DONT_CARE: VkAttachmentStoreOp = 1;
pub const VK_ATTACHMENT_STORE_OP_NONE: VkAttachmentStoreOp = 1000301000;
pub const VK_ATTACHMENT_STORE_OP_NONE_EXT: VkAttachmentStoreOp = VK_ATTACHMENT_STORE_OP_NONE;
pub const VK_ATTACHMENT_STORE_OP_NONE_KHR: VkAttachmentStoreOp = VK_ATTACHMENT_STORE_OP_NONE;
pub const VK_ATTACHMENT_STORE_OP_NONE_QCOM: VkAttachmentStoreOp = VK_ATTACHMENT_STORE_OP_NONE;
pub const VK_ATTACHMENT_STORE_OP_STORE: VkAttachmentStoreOp = 0;
pub const VK_ATTACHMENT_UNUSED: u32 = !0;
pub const VK_BLEND_FACTOR_CONSTANT_ALPHA: VkBlendFactor = 12;
pub const VK_BLEND_FACTOR_CONSTANT_COLOR: VkBlendFactor = 10;
pub const VK_BLEND_FACTOR_DST_ALPHA: VkBlendFactor = 8;
pub const VK_BLEND_FACTOR_DST_COLOR: VkBlendFactor = 4;
pub const VK_BLEND_FACTOR_ONE: VkBlendFactor = 1;
pub const VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA: VkBlendFactor = 13;
pub const VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR: VkBlendFactor = 11;
pub const VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA: VkBlendFactor = 9;
pub const VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR: VkBlendFactor = 5;
pub const VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA: VkBlendFactor = 18;
pub const VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR: VkBlendFactor = 16;
pub const VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA: VkBlendFactor = 7;
pub const VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR: VkBlendFactor = 3;
pub const VK_BLEND_FACTOR_SRC1_ALPHA: VkBlendFactor = 17;
pub const VK_BLEND_FACTOR_SRC1_COLOR: VkBlendFactor = 15;
pub const VK_BLEND_FACTOR_SRC_ALPHA: VkBlendFactor = 6;
pub const VK_BLEND_FACTOR_SRC_ALPHA_SATURATE: VkBlendFactor = 14;
pub const VK_BLEND_FACTOR_SRC_COLOR: VkBlendFactor = 2;
pub const VK_BLEND_FACTOR_ZERO: VkBlendFactor = 0;
pub const VK_BLEND_OP_ADD: VkBlendOp = 0;
pub const VK_BLEND_OP_BLUE_EXT: VkBlendOp = 1000148045;
pub const VK_BLEND_OP_COLORBURN_EXT: VkBlendOp = 1000148018;
pub const VK_BLEND_OP_COLORDODGE_EXT: VkBlendOp = 1000148017;
pub const VK_BLEND_OP_CONTRAST_EXT: VkBlendOp = 1000148041;
pub const VK_BLEND_OP_DARKEN_EXT: VkBlendOp = 1000148015;
pub const VK_BLEND_OP_DIFFERENCE_EXT: VkBlendOp = 1000148021;
pub const VK_BLEND_OP_DST_ATOP_EXT: VkBlendOp = 1000148010;
pub const VK_BLEND_OP_DST_EXT: VkBlendOp = 1000148002;
pub const VK_BLEND_OP_DST_IN_EXT: VkBlendOp = 1000148006;
pub const VK_BLEND_OP_DST_OUT_EXT: VkBlendOp = 1000148008;
pub const VK_BLEND_OP_DST_OVER_EXT: VkBlendOp = 1000148004;
pub const VK_BLEND_OP_EXCLUSION_EXT: VkBlendOp = 1000148022;
pub const VK_BLEND_OP_GREEN_EXT: VkBlendOp = 1000148044;
pub const VK_BLEND_OP_HARDLIGHT_EXT: VkBlendOp = 1000148019;
pub const VK_BLEND_OP_HARDMIX_EXT: VkBlendOp = 1000148030;
pub const VK_BLEND_OP_HSL_COLOR_EXT: VkBlendOp = 1000148033;
pub const VK_BLEND_OP_HSL_HUE_EXT: VkBlendOp = 1000148031;
pub const VK_BLEND_OP_HSL_LUMINOSITY_EXT: VkBlendOp = 1000148034;
pub const VK_BLEND_OP_HSL_SATURATION_EXT: VkBlendOp = 1000148032;
pub const VK_BLEND_OP_INVERT_EXT: VkBlendOp = 1000148023;
pub const VK_BLEND_OP_INVERT_OVG_EXT: VkBlendOp = 1000148042;
pub const VK_BLEND_OP_INVERT_RGB_EXT: VkBlendOp = 1000148024;
pub const VK_BLEND_OP_LIGHTEN_EXT: VkBlendOp = 1000148016;
pub const VK_BLEND_OP_LINEARBURN_EXT: VkBlendOp = 1000148026;
pub const VK_BLEND_OP_LINEARDODGE_EXT: VkBlendOp = 1000148025;
pub const VK_BLEND_OP_LINEARLIGHT_EXT: VkBlendOp = 1000148028;
pub const VK_BLEND_OP_MAX: VkBlendOp = 4;
pub const VK_BLEND_OP_MIN: VkBlendOp = 3;
pub const VK_BLEND_OP_MINUS_CLAMPED_EXT: VkBlendOp = 1000148040;
pub const VK_BLEND_OP_MINUS_EXT: VkBlendOp = 1000148039;
pub const VK_BLEND_OP_MULTIPLY_EXT: VkBlendOp = 1000148012;
pub const VK_BLEND_OP_OVERLAY_EXT: VkBlendOp = 1000148014;
pub const VK_BLEND_OP_PINLIGHT_EXT: VkBlendOp = 1000148029;
pub const VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT: VkBlendOp = 1000148037;
pub const VK_BLEND_OP_PLUS_CLAMPED_EXT: VkBlendOp = 1000148036;
pub const VK_BLEND_OP_PLUS_DARKER_EXT: VkBlendOp = 1000148038;
pub const VK_BLEND_OP_PLUS_EXT: VkBlendOp = 1000148035;
pub const VK_BLEND_OP_RED_EXT: VkBlendOp = 1000148043;
pub const VK_BLEND_OP_REVERSE_SUBTRACT: VkBlendOp = 2;
pub const VK_BLEND_OP_SCREEN_EXT: VkBlendOp = 1000148013;
pub const VK_BLEND_OP_SOFTLIGHT_EXT: VkBlendOp = 1000148020;
pub const VK_BLEND_OP_SRC_ATOP_EXT: VkBlendOp = 1000148009;
pub const VK_BLEND_OP_SRC_EXT: VkBlendOp = 1000148001;
pub const VK_BLEND_OP_SRC_IN_EXT: VkBlendOp = 1000148005;
pub const VK_BLEND_OP_SRC_OUT_EXT: VkBlendOp = 1000148007;
pub const VK_BLEND_OP_SRC_OVER_EXT: VkBlendOp = 1000148003;
pub const VK_BLEND_OP_SUBTRACT: VkBlendOp = 1;
pub const VK_BLEND_OP_VIVIDLIGHT_EXT: VkBlendOp = 1000148027;
pub const VK_BLEND_OP_XOR_EXT: VkBlendOp = 1000148011;
pub const VK_BLEND_OP_ZERO_EXT: VkBlendOp = 1000148000;
pub const VK_BLEND_OVERLAP_CONJOINT_EXT: VkBlendOverlapEXT = 2;
pub const VK_BLEND_OVERLAP_DISJOINT_EXT: VkBlendOverlapEXT = 1;
pub const VK_BLEND_OVERLAP_UNCORRELATED_EXT: VkBlendOverlapEXT = 0;
pub const VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM: VkBlockMatchWindowCompareModeQCOM = 1;
pub const VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM: VkBlockMatchWindowCompareModeQCOM = 0;
pub const VK_BORDER_COLOR_FLOAT_CUSTOM_EXT: VkBorderColor = 1000287003;
pub const VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK: VkBorderColor = 2;
pub const VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE: VkBorderColor = 4;
pub const VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK: VkBorderColor = 0;
pub const VK_BORDER_COLOR_INT_CUSTOM_EXT: VkBorderColor = 1000287004;
pub const VK_BORDER_COLOR_INT_OPAQUE_BLACK: VkBorderColor = 3;
pub const VK_BORDER_COLOR_INT_OPAQUE_WHITE: VkBorderColor = 5;
pub const VK_BORDER_COLOR_INT_TRANSPARENT_BLACK: VkBorderColor = 1;
pub const VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkBufferCreateFlagBits = 1 << 5;
pub const VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT: VkBufferCreateFlagBits = 1 << 4;
pub const VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT: VkBufferCreateFlagBits = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
pub const VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: VkBufferCreateFlagBits = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
pub const VK_BUFFER_CREATE_PROTECTED_BIT: VkBufferCreateFlagBits = 1 << 3;
pub const VK_BUFFER_CREATE_SPARSE_ALIASED_BIT: VkBufferCreateFlagBits = 1 << 2;
pub const VK_BUFFER_CREATE_SPARSE_BINDING_BIT: VkBufferCreateFlagBits = 1 << 0;
pub const VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT: VkBufferCreateFlagBits = 1 << 1;
pub const VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR: VkBufferCreateFlagBits = 1 << 6;
pub const VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 19;
pub const VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 20;
pub const VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 9;
pub const VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM: VkBufferUsageFlagBits2 = 1 << 29;
pub const VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 6;
pub const VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT;
pub const VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 8;
pub const VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT;
pub const VK_BUFFER_USAGE_2_MEMORY_DECOMPRESSION_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 32;
pub const VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 23;
pub const VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 24;
pub const VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 31;
pub const VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 26;
pub const VK_BUFFER_USAGE_2_RAY_TRACING_BIT_NV: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR;
pub const VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 22;
pub const VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 21;
pub const VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 10;
pub const VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT: VkBufferUsageFlagBits2 = 1 << 17;
pub const VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT;
pub const VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 5;
pub const VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT;
pub const VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 3;
pub const VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT;
pub const VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM: VkBufferUsageFlagBits2 = 1 << 27;
pub const VK_BUFFER_USAGE_2_TRANSFER_DST_BIT: VkBufferUsageFlagBits2 = 1 << 1;
pub const VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_TRANSFER_DST_BIT;
pub const VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT: VkBufferUsageFlagBits2 = 1 << 0;
pub const VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT;
pub const VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 11;
pub const VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 12;
pub const VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 4;
pub const VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT;
pub const VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 2;
pub const VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT;
pub const VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 7;
pub const VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT;
pub const VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 14;
pub const VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 13;
pub const VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 15;
pub const VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 16;
pub const VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR: VkBufferUsageFlagBits = 1 << 19;
pub const VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR: VkBufferUsageFlagBits = 1 << 20;
pub const VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT: VkBufferUsageFlagBits = 1 << 9;
pub const VK_BUFFER_USAGE_INDEX_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 6;
pub const VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 8;
pub const VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT: VkBufferUsageFlagBits = 1 << 23;
pub const VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT: VkBufferUsageFlagBits = 1 << 24;
pub const VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits = 1 << 26;
pub const VK_BUFFER_USAGE_RAY_TRACING_BIT_NV: VkBufferUsageFlagBits = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR;
pub const VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits = 1 << 22;
pub const VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits = 1 << 21;
pub const VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR: VkBufferUsageFlagBits = 1 << 10;
pub const VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT: VkBufferUsageFlagBits = 1 << 17;
pub const VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT: VkBufferUsageFlagBits = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
pub const VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR: VkBufferUsageFlagBits = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
pub const VK_BUFFER_USAGE_STORAGE_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 5;
pub const VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 3;
pub const VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM: VkBufferUsageFlagBits = 1 << 27;
pub const VK_BUFFER_USAGE_TRANSFER_DST_BIT: VkBufferUsageFlagBits = 1 << 1;
pub const VK_BUFFER_USAGE_TRANSFER_SRC_BIT: VkBufferUsageFlagBits = 1 << 0;
pub const VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT: VkBufferUsageFlagBits = 1 << 11;
pub const VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT: VkBufferUsageFlagBits = 1 << 12;
pub const VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 4;
pub const VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 2;
pub const VK_BUFFER_USAGE_VERTEX_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 7;
pub const VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR: VkBufferUsageFlagBits = 1 << 14;
pub const VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR: VkBufferUsageFlagBits = 1 << 13;
pub const VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR: VkBufferUsageFlagBits = 1 << 15;
pub const VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR: VkBufferUsageFlagBits = 1 << 16;
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = 1 << 12;
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 1;
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR;
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 11;
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR;
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT: VkBuildAccelerationStructureFlagBitsKHR = 1 << 7;
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT;
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT: VkBuildAccelerationStructureFlagBitsKHR = 1 << 8;
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT;
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT: VkBuildAccelerationStructureFlagBitsKHR = 1 << 6;
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT;
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 0;
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR;
pub const VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 4;
pub const VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR;
pub const VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR: VkBuildAccelerationStructureModeKHR = 0;
pub const VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR: VkBuildAccelerationStructureModeKHR = 1;
pub const VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = 1 << 5;
pub const VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 3;
pub const VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR;
pub const VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 2;
pub const VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR;
pub const VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT: VkBuildMicromapFlagBitsEXT = 1 << 2;
pub const VK_BUILD_MICROMAP_MODE_BUILD_EXT: VkBuildMicromapModeEXT = 0;
pub const VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT: VkBuildMicromapFlagBitsEXT = 1 << 1;
pub const VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT: VkBuildMicromapFlagBitsEXT = 1 << 0;
pub const VK_CHROMA_LOCATION_COSITED_EVEN: VkChromaLocation = 0;
pub const VK_CHROMA_LOCATION_COSITED_EVEN_KHR: VkChromaLocation = VK_CHROMA_LOCATION_COSITED_EVEN;
pub const VK_CHROMA_LOCATION_MIDPOINT: VkChromaLocation = 1;
pub const VK_CHROMA_LOCATION_MIDPOINT_KHR: VkChromaLocation = VK_CHROMA_LOCATION_MIDPOINT;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 2;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 0;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 3;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 1;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 4;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 5;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_NONE_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 0;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV: VkClusterAccelerationStructureClusterFlagBitsNV = 1 << 0;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV: VkClusterAccelerationStructureGeometryFlagBitsNV = 1 << 0;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV: VkClusterAccelerationStructureGeometryFlagBitsNV = 1 << 1;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV: VkClusterAccelerationStructureGeometryFlagBitsNV = 1 << 2;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV: VkClusterAccelerationStructureIndexFormatFlagBitsNV = 1 << 1;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV: VkClusterAccelerationStructureIndexFormatFlagBitsNV = 1 << 2;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV: VkClusterAccelerationStructureIndexFormatFlagBitsNV = 1 << 0;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV: VkClusterAccelerationStructureOpModeNV = 2;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV: VkClusterAccelerationStructureOpModeNV = 1;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV: VkClusterAccelerationStructureOpModeNV = 0;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV: VkClusterAccelerationStructureOpTypeNV = 1;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV: VkClusterAccelerationStructureOpTypeNV = 2;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV: VkClusterAccelerationStructureOpTypeNV = 3;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV: VkClusterAccelerationStructureOpTypeNV = 5;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV: VkClusterAccelerationStructureOpTypeNV = 4;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV: VkClusterAccelerationStructureOpTypeNV = 0;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV: VkClusterAccelerationStructureTypeNV = 0;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV: VkClusterAccelerationStructureTypeNV = 1;
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV: VkClusterAccelerationStructureTypeNV = 2;
pub const VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV: VkCoarseSampleOrderTypeNV = 1;
pub const VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV: VkCoarseSampleOrderTypeNV = 0;
pub const VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV: VkCoarseSampleOrderTypeNV = 2;
pub const VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV: VkCoarseSampleOrderTypeNV = 3;
pub const VK_COLORSPACE_SRGB_NONLINEAR_KHR: VkColorSpaceKHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
pub const VK_COLOR_COMPONENT_A_BIT: VkColorComponentFlagBits = 1 << 3;
pub const VK_COLOR_COMPONENT_B_BIT: VkColorComponentFlagBits = 1 << 2;
pub const VK_COLOR_COMPONENT_G_BIT: VkColorComponentFlagBits = 1 << 1;
pub const VK_COLOR_COMPONENT_R_BIT: VkColorComponentFlagBits = 1 << 0;
pub const VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT: VkColorSpaceKHR = 1000104011;
pub const VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT: VkColorSpaceKHR = 1000104012;
pub const VK_COLOR_SPACE_BT2020_LINEAR_EXT: VkColorSpaceKHR = 1000104007;
pub const VK_COLOR_SPACE_BT709_LINEAR_EXT: VkColorSpaceKHR = 1000104005;
pub const VK_COLOR_SPACE_BT709_NONLINEAR_EXT: VkColorSpaceKHR = 1000104006;
pub const VK_COLOR_SPACE_DCI_P3_LINEAR_EXT: VkColorSpaceKHR = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT;
pub const VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT: VkColorSpaceKHR = 1000104004;
pub const VK_COLOR_SPACE_DISPLAY_NATIVE_AMD: VkColorSpaceKHR = 1000213000;
pub const VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT: VkColorSpaceKHR = 1000104003;
pub const VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT: VkColorSpaceKHR = 1000104001;
pub const VK_COLOR_SPACE_DOLBYVISION_EXT: VkColorSpaceKHR = 1000104009;
pub const VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT: VkColorSpaceKHR = 1000104002;
pub const VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT: VkColorSpaceKHR = 1000104014;
pub const VK_COLOR_SPACE_HDR10_HLG_EXT: VkColorSpaceKHR = 1000104010;
pub const VK_COLOR_SPACE_HDR10_ST2084_EXT: VkColorSpaceKHR = 1000104008;
pub const VK_COLOR_SPACE_PASS_THROUGH_EXT: VkColorSpaceKHR = 1000104013;
pub const VK_COLOR_SPACE_SRGB_NONLINEAR_KHR: VkColorSpaceKHR = 0;
pub const VK_COMMAND_BUFFER_LEVEL_PRIMARY: VkCommandBufferLevel = 0;
pub const VK_COMMAND_BUFFER_LEVEL_SECONDARY: VkCommandBufferLevel = 1;
pub const VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT: VkCommandBufferResetFlagBits = 1 << 0;
pub const VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT: VkCommandBufferUsageFlagBits = 1 << 0;
pub const VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT: VkCommandBufferUsageFlagBits = 1 << 1;
pub const VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT: VkCommandBufferUsageFlagBits = 1 << 2;
pub const VK_COMMAND_POOL_CREATE_PROTECTED_BIT: VkCommandPoolCreateFlagBits = 1 << 2;
pub const VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT: VkCommandPoolCreateFlagBits = 1 << 1;
pub const VK_COMMAND_POOL_CREATE_TRANSIENT_BIT: VkCommandPoolCreateFlagBits = 1 << 0;
pub const VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT: VkCommandPoolResetFlagBits = 1 << 0;
pub const VK_COMPARE_OP_ALWAYS: VkCompareOp = 7;
pub const VK_COMPARE_OP_EQUAL: VkCompareOp = 2;
pub const VK_COMPARE_OP_GREATER: VkCompareOp = 4;
pub const VK_COMPARE_OP_GREATER_OR_EQUAL: VkCompareOp = 6;
pub const VK_COMPARE_OP_LESS: VkCompareOp = 1;
pub const VK_COMPARE_OP_LESS_OR_EQUAL: VkCompareOp = 3;
pub const VK_COMPARE_OP_NEVER: VkCompareOp = 0;
pub const VK_COMPARE_OP_NOT_EQUAL: VkCompareOp = 5;
pub const VK_COMPONENT_SWIZZLE_A: VkComponentSwizzle = 6;
pub const VK_COMPONENT_SWIZZLE_B: VkComponentSwizzle = 5;
pub const VK_COMPONENT_SWIZZLE_G: VkComponentSwizzle = 4;
pub const VK_COMPONENT_SWIZZLE_IDENTITY: VkComponentSwizzle = 0;
pub const VK_COMPONENT_SWIZZLE_ONE: VkComponentSwizzle = 2;
pub const VK_COMPONENT_SWIZZLE_R: VkComponentSwizzle = 3;
pub const VK_COMPONENT_SWIZZLE_ZERO: VkComponentSwizzle = 1;
pub const VK_COMPONENT_TYPE_BFLOAT16_KHR: VkComponentTypeKHR = 1000141000;
pub const VK_COMPONENT_TYPE_FLOAT16_KHR: VkComponentTypeKHR = 0;
pub const VK_COMPONENT_TYPE_FLOAT16_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT16_KHR;
pub const VK_COMPONENT_TYPE_FLOAT32_KHR: VkComponentTypeKHR = 1;
pub const VK_COMPONENT_TYPE_FLOAT32_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT32_KHR;
pub const VK_COMPONENT_TYPE_FLOAT64_KHR: VkComponentTypeKHR = 2;
pub const VK_COMPONENT_TYPE_FLOAT64_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT64_KHR;
pub const VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT: VkComponentTypeKHR = 1000491002;
pub const VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT: VkComponentTypeKHR = 1000491003;
pub const VK_COMPONENT_TYPE_FLOAT_E4M3_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT;
pub const VK_COMPONENT_TYPE_FLOAT_E5M2_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT;
pub const VK_COMPONENT_TYPE_SINT16_KHR: VkComponentTypeKHR = 4;
pub const VK_COMPONENT_TYPE_SINT16_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_SINT16_KHR;
pub const VK_COMPONENT_TYPE_SINT32_KHR: VkComponentTypeKHR = 5;
pub const VK_COMPONENT_TYPE_SINT32_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_SINT32_KHR;
pub const VK_COMPONENT_TYPE_SINT64_KHR: VkComponentTypeKHR = 6;
pub const VK_COMPONENT_TYPE_SINT64_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_SINT64_KHR;
pub const VK_COMPONENT_TYPE_SINT8_KHR: VkComponentTypeKHR = 3;
pub const VK_COMPONENT_TYPE_SINT8_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_SINT8_KHR;
pub const VK_COMPONENT_TYPE_SINT8_PACKED_NV: VkComponentTypeKHR = 1000491000;
pub const VK_COMPONENT_TYPE_UINT16_KHR: VkComponentTypeKHR = 8;
pub const VK_COMPONENT_TYPE_UINT16_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_UINT16_KHR;
pub const VK_COMPONENT_TYPE_UINT32_KHR: VkComponentTypeKHR = 9;
pub const VK_COMPONENT_TYPE_UINT32_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_UINT32_KHR;
pub const VK_COMPONENT_TYPE_UINT64_KHR: VkComponentTypeKHR = 10;
pub const VK_COMPONENT_TYPE_UINT64_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_UINT64_KHR;
pub const VK_COMPONENT_TYPE_UINT8_KHR: VkComponentTypeKHR = 7;
pub const VK_COMPONENT_TYPE_UINT8_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_UINT8_KHR;
pub const VK_COMPONENT_TYPE_UINT8_PACKED_NV: VkComponentTypeKHR = 1000491001;
pub const VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 1 << 3;
pub const VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 1 << 0;
pub const VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 1 << 2;
pub const VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 1 << 1;
pub const VK_COMPUTE_OCCUPANCY_PRIORITY_HIGH_NV: f32 = 0.75;
pub const VK_COMPUTE_OCCUPANCY_PRIORITY_LOW_NV: f32 = 0.25;
pub const VK_COMPUTE_OCCUPANCY_PRIORITY_NORMAL_NV: f32 = 0.50;
pub const VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT: VkConditionalRenderingFlagBitsEXT = 1 << 0;
pub const VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT: VkConservativeRasterizationModeEXT = 0;
pub const VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT: VkConservativeRasterizationModeEXT = 1;
pub const VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT: VkConservativeRasterizationModeEXT = 2;
pub const VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV: VkCooperativeVectorMatrixLayoutNV = 1;
pub const VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV: VkCooperativeVectorMatrixLayoutNV = 2;
pub const VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV: VkCooperativeVectorMatrixLayoutNV = 0;
pub const VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV: VkCooperativeVectorMatrixLayoutNV = 3;
pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR: VkCopyAccelerationStructureModeKHR = 0;
pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV: VkCopyAccelerationStructureModeKHR = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR;
pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR: VkCopyAccelerationStructureModeKHR = 1;
pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV: VkCopyAccelerationStructureModeKHR = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR;
pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR: VkCopyAccelerationStructureModeKHR = 3;
pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR: VkCopyAccelerationStructureModeKHR = 2;
pub const VK_COPY_MICROMAP_MODE_CLONE_EXT: VkCopyMicromapModeEXT = 0;
pub const VK_COPY_MICROMAP_MODE_COMPACT_EXT: VkCopyMicromapModeEXT = 3;
pub const VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT: VkCopyMicromapModeEXT = 2;
pub const VK_COPY_MICROMAP_MODE_SERIALIZE_EXT: VkCopyMicromapModeEXT = 1;
pub const VK_COVERAGE_MODULATION_MODE_ALPHA_NV: VkCoverageModulationModeNV = 2;
pub const VK_COVERAGE_MODULATION_MODE_NONE_NV: VkCoverageModulationModeNV = 0;
pub const VK_COVERAGE_MODULATION_MODE_RGBA_NV: VkCoverageModulationModeNV = 3;
pub const VK_COVERAGE_MODULATION_MODE_RGB_NV: VkCoverageModulationModeNV = 1;
pub const VK_COVERAGE_REDUCTION_MODE_MERGE_NV: VkCoverageReductionModeNV = 0;
pub const VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV: VkCoverageReductionModeNV = 1;
pub const VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM: VkCubicFilterWeightsQCOM = 2;
pub const VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM: VkCubicFilterWeightsQCOM = 0;
pub const VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM: VkCubicFilterWeightsQCOM = 3;
pub const VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM: VkCubicFilterWeightsQCOM = 1;
pub const VK_CULL_MODE_BACK_BIT: VkCullModeFlagBits = 1 << 1;
pub const VK_CULL_MODE_FRONT_AND_BACK: VkCullModeFlagBits = 0x00000003;
pub const VK_CULL_MODE_FRONT_BIT: VkCullModeFlagBits = 1 << 0;
pub const VK_CULL_MODE_NONE: VkCullModeFlagBits = 0;
pub const VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM: VkDataGraphModelCacheTypeQCOM = 0;
pub const VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM: u32 = 3;
pub const VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM: VkDataGraphPipelinePropertyARM = 0;
pub const VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM: VkDataGraphPipelinePropertyARM = 1;
pub const VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM: VkDataGraphPipelineSessionBindPointARM = 0;
pub const VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM: VkDataGraphPipelineSessionBindPointTypeARM = 0;
pub const VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM: VkDataGraphPipelineSessionCreateFlagBitsARM = 1 << 0;
pub const VK_DEBUG_REPORT_DEBUG_BIT_EXT: VkDebugReportFlagBitsEXT = 1 << 4;
pub const VK_DEBUG_REPORT_ERROR_BIT_EXT: VkDebugReportFlagBitsEXT = 1 << 3;
pub const VK_DEBUG_REPORT_INFORMATION_BIT_EXT: VkDebugReportFlagBitsEXT = 1 << 0;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT: VkDebugReportObjectTypeEXT = 1000150000;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT: VkDebugReportObjectTypeEXT = 1000165000;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT: VkDebugReportObjectTypeEXT = 9;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT: VkDebugReportObjectTypeEXT = 13;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT: VkDebugReportObjectTypeEXT = 6;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT: VkDebugReportObjectTypeEXT = 25;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT: VkDebugReportObjectTypeEXT = 1000029001;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT: VkDebugReportObjectTypeEXT = 1000029000;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT: VkDebugReportObjectTypeEXT = 28;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT: VkDebugReportObjectTypeEXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT: VkDebugReportObjectTypeEXT = 22;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT: VkDebugReportObjectTypeEXT = 23;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT: VkDebugReportObjectTypeEXT = 20;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT: VkDebugReportObjectTypeEXT = 1000085000;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT: VkDebugReportObjectTypeEXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT: VkDebugReportObjectTypeEXT = 3;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT: VkDebugReportObjectTypeEXT = 8;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT: VkDebugReportObjectTypeEXT = 29;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT: VkDebugReportObjectTypeEXT = 30;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT: VkDebugReportObjectTypeEXT = 11;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT: VkDebugReportObjectTypeEXT = 7;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT: VkDebugReportObjectTypeEXT = 24;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT: VkDebugReportObjectTypeEXT = 10;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT: VkDebugReportObjectTypeEXT = 14;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT: VkDebugReportObjectTypeEXT = 1;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT: VkDebugReportObjectTypeEXT = 2;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT: VkDebugReportObjectTypeEXT = 16;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT: VkDebugReportObjectTypeEXT = 19;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT: VkDebugReportObjectTypeEXT = 17;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT: VkDebugReportObjectTypeEXT = 12;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT: VkDebugReportObjectTypeEXT = 4;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT: VkDebugReportObjectTypeEXT = 18;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT: VkDebugReportObjectTypeEXT = 21;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT: VkDebugReportObjectTypeEXT = 1000156000;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT: VkDebugReportObjectTypeEXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT: VkDebugReportObjectTypeEXT = 5;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT: VkDebugReportObjectTypeEXT = 15;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT: VkDebugReportObjectTypeEXT = 26;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT: VkDebugReportObjectTypeEXT = 27;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT: VkDebugReportObjectTypeEXT = 0;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT: VkDebugReportObjectTypeEXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT;
pub const VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT: VkDebugReportObjectTypeEXT = 33;
pub const VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT: VkDebugReportFlagBitsEXT = 1 << 2;
pub const VK_DEBUG_REPORT_WARNING_BIT_EXT: VkDebugReportFlagBitsEXT = 1 << 1;
pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: VkDebugUtilsMessageSeverityFlagBitsEXT = 1 << 12;
pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT: VkDebugUtilsMessageSeverityFlagBitsEXT = 1 << 4;
pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: VkDebugUtilsMessageSeverityFlagBitsEXT = 1 << 0;
pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT: VkDebugUtilsMessageSeverityFlagBitsEXT = 1 << 8;
pub const VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT: VkDebugUtilsMessageTypeFlagBitsEXT = 1 << 3;
pub const VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT: VkDebugUtilsMessageTypeFlagBitsEXT = 1 << 0;
pub const VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT: VkDebugUtilsMessageTypeFlagBitsEXT = 1 << 2;
pub const VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT: VkDebugUtilsMessageTypeFlagBitsEXT = 1 << 1;
pub const VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR: VkDefaultVertexAttributeValueKHR = 1;
pub const VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR: VkDefaultVertexAttributeValueKHR = 0;
pub const VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR: VkDependencyFlagBits = 1 << 6;
pub const VK_DEPENDENCY_BY_REGION_BIT: VkDependencyFlagBits = 1 << 0;
pub const VK_DEPENDENCY_DEVICE_GROUP_BIT: VkDependencyFlagBits = 1 << 2;
pub const VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR: VkDependencyFlagBits = VK_DEPENDENCY_DEVICE_GROUP_BIT;
pub const VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT: VkDependencyFlagBits = 1 << 3;
pub const VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR: VkDependencyFlagBits = 1 << 5;
pub const VK_DEPENDENCY_VIEW_LOCAL_BIT: VkDependencyFlagBits = 1 << 1;
pub const VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR: VkDependencyFlagBits = VK_DEPENDENCY_VIEW_LOCAL_BIT;
pub const VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT: VkDepthBiasRepresentationEXT = 2;
pub const VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT: VkDepthBiasRepresentationEXT = 1;
pub const VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT: VkDepthBiasRepresentationEXT = 0;
pub const VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT: VkDepthClampModeEXT = 1;
pub const VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT: VkDepthClampModeEXT = 0;
pub const VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT: VkDescriptorBindingFlagBits = 1 << 2;
pub const VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT: VkDescriptorBindingFlagBits = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT;
pub const VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT: VkDescriptorBindingFlagBits = 1 << 0;
pub const VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT: VkDescriptorBindingFlagBits = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT;
pub const VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT: VkDescriptorBindingFlagBits = 1 << 1;
pub const VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT: VkDescriptorBindingFlagBits = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT;
pub const VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT: VkDescriptorBindingFlagBits = 1 << 3;
pub const VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT: VkDescriptorBindingFlagBits = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT;
pub const VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV: VkDescriptorPoolCreateFlagBits = 1 << 4;
pub const VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV: VkDescriptorPoolCreateFlagBits = 1 << 3;
pub const VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT: VkDescriptorPoolCreateFlagBits = 1 << 0;
pub const VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT: VkDescriptorPoolCreateFlagBits = 1 << 2;
pub const VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE: VkDescriptorPoolCreateFlagBits = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT;
pub const VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT: VkDescriptorPoolCreateFlagBits = 1 << 1;
pub const VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT: VkDescriptorPoolCreateFlagBits = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT;
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT: VkDescriptorSetLayoutCreateFlagBits = 1 << 4;
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT: VkDescriptorSetLayoutCreateFlagBits = 1 << 5;
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT: VkDescriptorSetLayoutCreateFlagBits = 1 << 2;
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE: VkDescriptorSetLayoutCreateFlagBits = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT;
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV: VkDescriptorSetLayoutCreateFlagBits = 1 << 7;
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV: VkDescriptorSetLayoutCreateFlagBits = 1 << 6;
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT: VkDescriptorSetLayoutCreateFlagBits = 1 << 0;
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR: VkDescriptorSetLayoutCreateFlagBits = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT;
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT: VkDescriptorSetLayoutCreateFlagBits = 1 << 1;
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT: VkDescriptorSetLayoutCreateFlagBits = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT;
pub const VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: VkDescriptorType = 1000150000;
pub const VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV: VkDescriptorType = 1000165000;
pub const VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM: VkDescriptorType = 1000440001;
pub const VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: VkDescriptorType = 1;
pub const VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK: VkDescriptorType = 1000138000;
pub const VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT: VkDescriptorType = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK;
pub const VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: VkDescriptorType = 10;
pub const VK_DESCRIPTOR_TYPE_MUTABLE_EXT: VkDescriptorType = 1000351000;
pub const VK_DESCRIPTOR_TYPE_MUTABLE_VALVE: VkDescriptorType = VK_DESCRIPTOR_TYPE_MUTABLE_EXT;
pub const VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV: VkDescriptorType = 1000570000;
pub const VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: VkDescriptorType = 2;
pub const VK_DESCRIPTOR_TYPE_SAMPLER: VkDescriptorType = 0;
pub const VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM: VkDescriptorType = 1000440000;
pub const VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: VkDescriptorType = 7;
pub const VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: VkDescriptorType = 9;
pub const VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: VkDescriptorType = 3;
pub const VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: VkDescriptorType = 5;
pub const VK_DESCRIPTOR_TYPE_TENSOR_ARM: VkDescriptorType = 1000460000;
pub const VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: VkDescriptorType = 6;
pub const VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: VkDescriptorType = 8;
pub const VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: VkDescriptorType = 4;
pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET: VkDescriptorUpdateTemplateType = 0;
pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR: VkDescriptorUpdateTemplateType = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET;
pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS: VkDescriptorUpdateTemplateType = 1;
pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR: VkDescriptorUpdateTemplateType = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS;
pub const VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT: VkDeviceAddressBindingFlagBitsEXT = 1 << 0;
pub const VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT: VkDeviceAddressBindingTypeEXT = 0;
pub const VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT: VkDeviceAddressBindingTypeEXT = 1;
pub const VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV: VkDeviceDiagnosticsConfigFlagBitsNV = 1 << 2;
pub const VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV: VkDeviceDiagnosticsConfigFlagBitsNV = 1 << 1;
pub const VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV: VkDeviceDiagnosticsConfigFlagBitsNV = 1 << 0;
pub const VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV: VkDeviceDiagnosticsConfigFlagBitsNV = 1 << 3;
pub const VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT: VkDeviceEventTypeEXT = 0;
pub const VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT: VkDeviceFaultAddressTypeEXT = 3;
pub const VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT: VkDeviceFaultAddressTypeEXT = 6;
pub const VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT: VkDeviceFaultAddressTypeEXT = 5;
pub const VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT: VkDeviceFaultAddressTypeEXT = 4;
pub const VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT: VkDeviceFaultAddressTypeEXT = 0;
pub const VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT: VkDeviceFaultAddressTypeEXT = 1;
pub const VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT: VkDeviceFaultAddressTypeEXT = 2;
pub const VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT: VkDeviceFaultVendorBinaryHeaderVersionEXT = 1;
pub const VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR: VkDeviceGroupPresentModeFlagBitsKHR = 1 << 0;
pub const VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR: VkDeviceGroupPresentModeFlagBitsKHR = 1 << 3;
pub const VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR: VkDeviceGroupPresentModeFlagBitsKHR = 1 << 1;
pub const VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR: VkDeviceGroupPresentModeFlagBitsKHR = 1 << 2;
pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT: VkDeviceMemoryReportEventTypeEXT = 0;
pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT: VkDeviceMemoryReportEventTypeEXT = 4;
pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT: VkDeviceMemoryReportEventTypeEXT = 1;
pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT: VkDeviceMemoryReportEventTypeEXT = 2;
pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT: VkDeviceMemoryReportEventTypeEXT = 3;
pub const VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT: VkDeviceQueueCreateFlagBits = 1 << 0;
pub const VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG: VkDirectDriverLoadingModeLUNARG = 0;
pub const VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG: VkDirectDriverLoadingModeLUNARG = 1;
pub const VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT: VkDiscardRectangleModeEXT = 1;
pub const VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT: VkDiscardRectangleModeEXT = 0;
pub const VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT: VkDisplayEventTypeEXT = 0;
pub const VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR: VkDisplayPlaneAlphaFlagBitsKHR = 1 << 1;
pub const VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR: VkDisplayPlaneAlphaFlagBitsKHR = 1 << 0;
pub const VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR: VkDisplayPlaneAlphaFlagBitsKHR = 1 << 2;
pub const VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR: VkDisplayPlaneAlphaFlagBitsKHR = 1 << 3;
pub const VK_DISPLAY_POWER_STATE_OFF_EXT: VkDisplayPowerStateEXT = 0;
pub const VK_DISPLAY_POWER_STATE_ON_EXT: VkDisplayPowerStateEXT = 2;
pub const VK_DISPLAY_POWER_STATE_SUSPEND_EXT: VkDisplayPowerStateEXT = 1;
pub const VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV: VkDisplaySurfaceStereoTypeNV = 2;
pub const VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV: VkDisplaySurfaceStereoTypeNV = 3;
pub const VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV: VkDisplaySurfaceStereoTypeNV = 0;
pub const VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV: VkDisplaySurfaceStereoTypeNV = 1;
pub const VK_DRIVER_ID_AMD_OPEN_SOURCE: VkDriverId = 2;
pub const VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR: VkDriverId = VK_DRIVER_ID_AMD_OPEN_SOURCE;
pub const VK_DRIVER_ID_AMD_PROPRIETARY: VkDriverId = 1;
pub const VK_DRIVER_ID_AMD_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_AMD_PROPRIETARY;
pub const VK_DRIVER_ID_ARM_PROPRIETARY: VkDriverId = 9;
pub const VK_DRIVER_ID_ARM_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_ARM_PROPRIETARY;
pub const VK_DRIVER_ID_BROADCOM_PROPRIETARY: VkDriverId = 12;
pub const VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_BROADCOM_PROPRIETARY;
pub const VK_DRIVER_ID_COREAVI_PROPRIETARY: VkDriverId = 15;
pub const VK_DRIVER_ID_GGP_PROPRIETARY: VkDriverId = 11;
pub const VK_DRIVER_ID_GGP_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_GGP_PROPRIETARY;
pub const VK_DRIVER_ID_GOOGLE_SWIFTSHADER: VkDriverId = 10;
pub const VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR: VkDriverId = VK_DRIVER_ID_GOOGLE_SWIFTSHADER;
pub const VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA: VkDriverId = 25;
pub const VK_DRIVER_ID_IMAGINATION_PROPRIETARY: VkDriverId = 7;
pub const VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_IMAGINATION_PROPRIETARY;
pub const VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA: VkDriverId = 6;
pub const VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR: VkDriverId = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA;
pub const VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS: VkDriverId = 5;
pub const VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR: VkDriverId = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS;
pub const VK_DRIVER_ID_JUICE_PROPRIETARY: VkDriverId = 16;
pub const VK_DRIVER_ID_MESA_DOZEN: VkDriverId = 23;
pub const VK_DRIVER_ID_MESA_HONEYKRISP: VkDriverId = 26;
pub const VK_DRIVER_ID_MESA_KOSMICKRISP: VkDriverId = 28;
pub const VK_DRIVER_ID_MESA_LLVMPIPE: VkDriverId = 13;
pub const VK_DRIVER_ID_MESA_NVK: VkDriverId = 24;
pub const VK_DRIVER_ID_MESA_PANVK: VkDriverId = 20;
pub const VK_DRIVER_ID_MESA_RADV: VkDriverId = 3;
pub const VK_DRIVER_ID_MESA_RADV_KHR: VkDriverId = VK_DRIVER_ID_MESA_RADV;
pub const VK_DRIVER_ID_MESA_TURNIP: VkDriverId = 18;
pub const VK_DRIVER_ID_MESA_V3DV: VkDriverId = 19;
pub const VK_DRIVER_ID_MESA_VENUS: VkDriverId = 22;
pub const VK_DRIVER_ID_MOLTENVK: VkDriverId = 14;
pub const VK_DRIVER_ID_NVIDIA_PROPRIETARY: VkDriverId = 4;
pub const VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_NVIDIA_PROPRIETARY;
pub const VK_DRIVER_ID_QUALCOMM_PROPRIETARY: VkDriverId = 8;
pub const VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_QUALCOMM_PROPRIETARY;
pub const VK_DRIVER_ID_SAMSUNG_PROPRIETARY: VkDriverId = 21;
pub const VK_DRIVER_ID_VERISILICON_PROPRIETARY: VkDriverId = 17;
pub const VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN: VkDriverId = 27;
pub const VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT: VkDynamicState = 1000455007;
pub const VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT: VkDynamicState = 1000455008;
pub const VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT: VkDynamicState = 1000524000;
pub const VK_DYNAMIC_STATE_BLEND_CONSTANTS: VkDynamicState = 4;
pub const VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT: VkDynamicState = 1000455018;
pub const VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT: VkDynamicState = 1000455010;
pub const VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT: VkDynamicState = 1000455011;
pub const VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT: VkDynamicState = 1000381000;
pub const VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT: VkDynamicState = 1000455012;
pub const VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT: VkDynamicState = 1000455014;
pub const VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV: VkDynamicState = 1000455027;
pub const VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV: VkDynamicState = 1000455028;
pub const VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV: VkDynamicState = 1000455029;
pub const VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV: VkDynamicState = 1000455032;
pub const VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV: VkDynamicState = 1000455025;
pub const VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV: VkDynamicState = 1000455026;
pub const VK_DYNAMIC_STATE_CULL_MODE: VkDynamicState = 1000267000;
pub const VK_DYNAMIC_STATE_CULL_MODE_EXT: VkDynamicState = VK_DYNAMIC_STATE_CULL_MODE;
pub const VK_DYNAMIC_STATE_DEPTH_BIAS: VkDynamicState = 3;
pub const VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE: VkDynamicState = 1000377002;
pub const VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE;
pub const VK_DYNAMIC_STATE_DEPTH_BOUNDS: VkDynamicState = 5;
pub const VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE: VkDynamicState = 1000267009;
pub const VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE;
pub const VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT: VkDynamicState = 1000455003;
pub const VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT: VkDynamicState = 1000582000;
pub const VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT: VkDynamicState = 1000455016;
pub const VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT: VkDynamicState = 1000455022;
pub const VK_DYNAMIC_STATE_DEPTH_COMPARE_OP: VkDynamicState = 1000267008;
pub const VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP;
pub const VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE: VkDynamicState = 1000267006;
pub const VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE;
pub const VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE: VkDynamicState = 1000267007;
pub const VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE;
pub const VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT: VkDynamicState = 1000099001;
pub const VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT: VkDynamicState = 1000099000;
pub const VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT: VkDynamicState = 1000099002;
pub const VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV: VkDynamicState = 1000205000;
pub const VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV: VkDynamicState = 1000205001;
pub const VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT: VkDynamicState = 1000455015;
pub const VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR: VkDynamicState = 1000226000;
pub const VK_DYNAMIC_STATE_FRONT_FACE: VkDynamicState = 1000267001;
pub const VK_DYNAMIC_STATE_FRONT_FACE_EXT: VkDynamicState = VK_DYNAMIC_STATE_FRONT_FACE;
pub const VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT: VkDynamicState = 1000455020;
pub const VK_DYNAMIC_STATE_LINE_STIPPLE: VkDynamicState = 1000259000;
pub const VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT: VkDynamicState = 1000455021;
pub const VK_DYNAMIC_STATE_LINE_STIPPLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_LINE_STIPPLE;
pub const VK_DYNAMIC_STATE_LINE_STIPPLE_KHR: VkDynamicState = VK_DYNAMIC_STATE_LINE_STIPPLE;
pub const VK_DYNAMIC_STATE_LINE_WIDTH: VkDynamicState = 2;
pub const VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT: VkDynamicState = 1000455009;
pub const VK_DYNAMIC_STATE_LOGIC_OP_EXT: VkDynamicState = 1000377003;
pub const VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT: VkDynamicState = 1000377000;
pub const VK_DYNAMIC_STATE_POLYGON_MODE_EXT: VkDynamicState = 1000455004;
pub const VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE: VkDynamicState = 1000377004;
pub const VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE;
pub const VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY: VkDynamicState = 1000267002;
pub const VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT: VkDynamicState = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY;
pub const VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT: VkDynamicState = 1000455019;
pub const VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT: VkDynamicState = 1000455005;
pub const VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT: VkDynamicState = 1000455013;
pub const VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE: VkDynamicState = 1000377001;
pub const VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE;
pub const VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR: VkDynamicState = 1000347000;
pub const VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV: VkDynamicState = 1000455031;
pub const VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT: VkDynamicState = 1000455017;
pub const VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT: VkDynamicState = 1000143000;
pub const VK_DYNAMIC_STATE_SAMPLE_MASK_EXT: VkDynamicState = 1000455006;
pub const VK_DYNAMIC_STATE_SCISSOR: VkDynamicState = 1;
pub const VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT: VkDynamicState = 1000267004;
pub const VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT: VkDynamicState = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT;
pub const VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV: VkDynamicState = 1000455030;
pub const VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK: VkDynamicState = 6;
pub const VK_DYNAMIC_STATE_STENCIL_OP: VkDynamicState = 1000267011;
pub const VK_DYNAMIC_STATE_STENCIL_OP_EXT: VkDynamicState = VK_DYNAMIC_STATE_STENCIL_OP;
pub const VK_DYNAMIC_STATE_STENCIL_REFERENCE: VkDynamicState = 8;
pub const VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE: VkDynamicState = 1000267010;
pub const VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE;
pub const VK_DYNAMIC_STATE_STENCIL_WRITE_MASK: VkDynamicState = 7;
pub const VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT: VkDynamicState = 1000455002;
pub const VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE: VkDynamicState = 1000267005;
pub const VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT: VkDynamicState = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE;
pub const VK_DYNAMIC_STATE_VERTEX_INPUT_EXT: VkDynamicState = 1000352000;
pub const VK_DYNAMIC_STATE_VIEWPORT: VkDynamicState = 0;
pub const VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV: VkDynamicState = 1000164006;
pub const VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV: VkDynamicState = 1000164004;
pub const VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV: VkDynamicState = 1000455024;
pub const VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT: VkDynamicState = 1000267003;
pub const VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT: VkDynamicState = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT;
pub const VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV: VkDynamicState = 1000455023;
pub const VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV: VkDynamicState = 1000087000;
pub const VK_ERROR_COMPRESSION_EXHAUSTED_EXT: VkResult = -1000338000;
pub const VK_ERROR_DEVICE_LOST: VkResult = -4;
pub const VK_ERROR_EXTENSION_NOT_PRESENT: VkResult = -7;
pub const VK_ERROR_FEATURE_NOT_PRESENT: VkResult = -8;
pub const VK_ERROR_FORMAT_NOT_SUPPORTED: VkResult = -11;
pub const VK_ERROR_FRAGMENTATION: VkResult = -1000161000;
pub const VK_ERROR_FRAGMENTATION_EXT: VkResult = VK_ERROR_FRAGMENTATION;
pub const VK_ERROR_FRAGMENTED_POOL: VkResult = -12;
pub const VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR: VkResult = -1000023000;
pub const VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: VkResult = -1000003001;
pub const VK_ERROR_INCOMPATIBLE_DRIVER: VkResult = -9;
pub const VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT: VkResult = VK_INCOMPATIBLE_SHADER_BINARY_EXT;
pub const VK_ERROR_INITIALIZATION_FAILED: VkResult = -3;
pub const VK_ERROR_INVALID_DEVICE_ADDRESS_EXT: VkResult = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS;
pub const VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: VkResult = -1000158000;
pub const VK_ERROR_INVALID_EXTERNAL_HANDLE: VkResult = -1000072003;
pub const VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR: VkResult = VK_ERROR_INVALID_EXTERNAL_HANDLE;
pub const VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: VkResult = -1000257000;
pub const VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR: VkResult = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS;
pub const VK_ERROR_INVALID_SHADER_NV: VkResult = -1000012000;
pub const VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR: VkResult = -1000299000;
pub const VK_ERROR_LAYER_NOT_PRESENT: VkResult = -6;
pub const VK_ERROR_MEMORY_MAP_FAILED: VkResult = -5;
pub const VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: VkResult = -1000000001;
pub const VK_ERROR_NOT_ENOUGH_SPACE_KHR: VkResult = -1000483000;
pub const VK_ERROR_NOT_PERMITTED: VkResult = -1000174001;
pub const VK_ERROR_NOT_PERMITTED_EXT: VkResult = VK_ERROR_NOT_PERMITTED;
pub const VK_ERROR_NOT_PERMITTED_KHR: VkResult = VK_ERROR_NOT_PERMITTED;
pub const VK_ERROR_OUT_OF_DATE_KHR: VkResult = -1000001004;
pub const VK_ERROR_OUT_OF_DEVICE_MEMORY: VkResult = -2;
pub const VK_ERROR_OUT_OF_HOST_MEMORY: VkResult = -1;
pub const VK_ERROR_OUT_OF_POOL_MEMORY: VkResult = -1000069000;
pub const VK_ERROR_OUT_OF_POOL_MEMORY_KHR: VkResult = VK_ERROR_OUT_OF_POOL_MEMORY;
pub const VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT: VkResult = VK_PIPELINE_COMPILE_REQUIRED;
pub const VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT: VkResult = -1000208000;
pub const VK_ERROR_SURFACE_LOST_KHR: VkResult = -1000000000;
pub const VK_ERROR_TOO_MANY_OBJECTS: VkResult = -10;
pub const VK_ERROR_UNKNOWN: VkResult = -13;
pub const VK_ERROR_VALIDATION_FAILED: VkResult = -1000011001;
pub const VK_ERROR_VALIDATION_FAILED_EXT: VkResult = VK_ERROR_VALIDATION_FAILED;
pub const VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR: VkResult = -1000023001;
pub const VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR: VkResult = -1000023004;
pub const VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR: VkResult = -1000023003;
pub const VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR: VkResult = -1000023002;
pub const VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR: VkResult = -1000023005;
pub const VK_EVENT_CREATE_DEVICE_ONLY_BIT: VkEventCreateFlagBits = 1 << 0;
pub const VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR: VkEventCreateFlagBits = VK_EVENT_CREATE_DEVICE_ONLY_BIT;
pub const VK_EVENT_RESET: VkResult = 4;
pub const VK_EVENT_SET: VkResult = 3;
pub const VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT: VkExternalFenceFeatureFlagBits = 1 << 0;
pub const VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR: VkExternalFenceFeatureFlagBits = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT;
pub const VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT: VkExternalFenceFeatureFlagBits = 1 << 1;
pub const VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR: VkExternalFenceFeatureFlagBits = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT;
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT: VkExternalFenceHandleTypeFlagBits = 1 << 0;
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: VkExternalFenceHandleTypeFlagBits = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT;
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT: VkExternalFenceHandleTypeFlagBits = 1 << 1;
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR: VkExternalFenceHandleTypeFlagBits = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT;
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: VkExternalFenceHandleTypeFlagBits = 1 << 2;
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR: VkExternalFenceHandleTypeFlagBits = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT;
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT: VkExternalFenceHandleTypeFlagBits = 1 << 3;
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR: VkExternalFenceHandleTypeFlagBits = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT;
pub const VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT: VkExternalMemoryFeatureFlagBits = 1 << 0;
pub const VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR: VkExternalMemoryFeatureFlagBits = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT;
pub const VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV: VkExternalMemoryFeatureFlagBitsNV = 1 << 0;
pub const VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT: VkExternalMemoryFeatureFlagBits = 1 << 1;
pub const VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR: VkExternalMemoryFeatureFlagBits = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
pub const VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV: VkExternalMemoryFeatureFlagBitsNV = 1 << 1;
pub const VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT: VkExternalMemoryFeatureFlagBits = 1 << 2;
pub const VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR: VkExternalMemoryFeatureFlagBits = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
pub const VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV: VkExternalMemoryFeatureFlagBitsNV = 1 << 2;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV: VkExternalMemoryHandleTypeFlagBitsNV = 1 << 2;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV: VkExternalMemoryHandleTypeFlagBitsNV = 1 << 3;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 3;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 4;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 5;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 6;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT: VkExternalMemoryHandleTypeFlagBits = 1 << 9;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT: VkExternalMemoryHandleTypeFlagBits = 1 << 7;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT: VkExternalMemoryHandleTypeFlagBits = 1 << 8;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 0;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 1;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV: VkExternalMemoryHandleTypeFlagBitsNV = 1 << 0;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 2;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV: VkExternalMemoryHandleTypeFlagBitsNV = 1 << 1;
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV: VkExternalMemoryHandleTypeFlagBits = 1 << 12;
pub const VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT: VkExternalSemaphoreFeatureFlagBits = 1 << 0;
pub const VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR: VkExternalSemaphoreFeatureFlagBits = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT;
pub const VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT: VkExternalSemaphoreFeatureFlagBits = 1 << 1;
pub const VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR: VkExternalSemaphoreFeatureFlagBits = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT;
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT: VkExternalSemaphoreHandleTypeFlagBits = 1 << 3;
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT;
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT: VkExternalSemaphoreHandleTypeFlagBits = 1 << 0;
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT: VkExternalSemaphoreHandleTypeFlagBits = 1 << 1;
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT;
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: VkExternalSemaphoreHandleTypeFlagBits = 1 << 2;
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT;
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT: VkExternalSemaphoreHandleTypeFlagBits = 1 << 4;
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
pub const VK_EXT_4444_FORMATS_EXTENSION_NAME: &CStr = c"VK_EXT_4444_formats";
pub const VK_EXT_4444_FORMATS_SPEC_VERSION: u32 = 1;
pub const VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME: &CStr = c"VK_EXT_acquire_drm_display";
pub const VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION: u32 = 1;
pub const VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME: &CStr = c"VK_EXT_astc_decode_mode";
pub const VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME: &CStr = c"VK_EXT_attachment_feedback_loop_dynamic_state";
pub const VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME: &CStr = c"VK_EXT_attachment_feedback_loop_layout";
pub const VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION: u32 = 2;
pub const VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME: &CStr = c"VK_EXT_blend_operation_advanced";
pub const VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION: u32 = 2;
pub const VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME: &CStr = c"VK_EXT_border_color_swizzle";
pub const VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME: &CStr = c"VK_EXT_buffer_device_address";
pub const VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION: u32 = 2;
pub const VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME: &CStr = c"VK_EXT_calibrated_timestamps";
pub const VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION: u32 = 2;
pub const VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME: &CStr = c"VK_EXT_color_write_enable";
pub const VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME: &CStr = c"VK_EXT_conditional_rendering";
pub const VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION: u32 = 2;
pub const VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME: &CStr = c"VK_EXT_conservative_rasterization";
pub const VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION: u32 = 1;
pub const VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME: &CStr = c"VK_EXT_custom_border_color";
pub const VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION: u32 = 12;
pub const VK_EXT_CUSTOM_RESOLVE_EXTENSION_NAME: &CStr = c"VK_EXT_custom_resolve";
pub const VK_EXT_CUSTOM_RESOLVE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_DEBUG_MARKER_EXTENSION_NAME: &CStr = c"VK_EXT_debug_marker";
pub const VK_EXT_DEBUG_MARKER_SPEC_VERSION: u32 = 4;
pub const VK_EXT_DEBUG_REPORT_EXTENSION_NAME: &CStr = c"VK_EXT_debug_report";
pub const VK_EXT_DEBUG_REPORT_SPEC_VERSION: u32 = 10;
pub const VK_EXT_DEBUG_UTILS_EXTENSION_NAME: &CStr = c"VK_EXT_debug_utils";
pub const VK_EXT_DEBUG_UTILS_SPEC_VERSION: u32 = 2;
pub const VK_EXT_DEPTH_BIAS_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_depth_bias_control";
pub const VK_EXT_DEPTH_BIAS_CONTROL_SPEC_VERSION: u32 = 1;
pub const VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_depth_clamp_control";
pub const VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION: u32 = 1;
pub const VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME: &CStr = c"VK_EXT_depth_clamp_zero_one";
pub const VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_depth_clip_control";
pub const VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION: u32 = 1;
pub const VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME: &CStr = c"VK_EXT_depth_clip_enable";
pub const VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME: &CStr = c"VK_EXT_depth_range_unrestricted";
pub const VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION: u32 = 1;
pub const VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME: &CStr = c"VK_EXT_descriptor_buffer";
pub const VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION: u32 = 1;
pub const VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME: &CStr = c"VK_EXT_descriptor_indexing";
pub const VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION: u32 = 2;
pub const VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME: &CStr = c"VK_EXT_device_address_binding_report";
pub const VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION: u32 = 1;
pub const VK_EXT_DEVICE_FAULT_EXTENSION_NAME: &CStr = c"VK_EXT_device_fault";
pub const VK_EXT_DEVICE_FAULT_SPEC_VERSION: u32 = 2;
pub const VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME: &CStr = c"VK_EXT_device_generated_commands";
pub const VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION: u32 = 1;
pub const VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME: &CStr = c"VK_EXT_device_memory_report";
pub const VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION: u32 = 2;
pub const VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME: &CStr = c"VK_EXT_direct_mode_display";
pub const VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION: u32 = 1;
pub const VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME: &CStr = c"VK_EXT_discard_rectangles";
pub const VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION: u32 = 2;
pub const VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_display_control";
pub const VK_EXT_DISPLAY_CONTROL_SPEC_VERSION: u32 = 1;
pub const VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME: &CStr = c"VK_EXT_display_surface_counter";
pub const VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION: u32 = 1;
pub const VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME: &CStr = c"VK_EXT_dynamic_rendering_unused_attachments";
pub const VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION: u32 = 1;
pub const VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME: &CStr = c"VK_EXT_extended_dynamic_state2";
pub const VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION: u32 = 1;
pub const VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME: &CStr = c"VK_EXT_extended_dynamic_state3";
pub const VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION: u32 = 2;
pub const VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME: &CStr = c"VK_EXT_extended_dynamic_state";
pub const VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXTENSION_NAME: &CStr = c"VK_EXT_external_memory_acquire_unmodified";
pub const VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION: u32 = 1;
pub const VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME: &CStr = c"VK_EXT_external_memory_dma_buf";
pub const VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION: u32 = 1;
pub const VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME: &CStr = c"VK_EXT_external_memory_host";
pub const VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION: u32 = 1;
pub const VK_EXT_FILTER_CUBIC_EXTENSION_NAME: &CStr = c"VK_EXT_filter_cubic";
pub const VK_EXT_FILTER_CUBIC_SPEC_VERSION: u32 = 3;
pub const VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME: &CStr = c"VK_EXT_fragment_density_map2";
pub const VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION: u32 = 1;
pub const VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME: &CStr = c"VK_EXT_fragment_density_map";
pub const VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME: &CStr = c"VK_EXT_fragment_density_map_offset";
pub const VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION: u32 = 1;
pub const VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION: u32 = 2;
pub const VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME: &CStr = c"VK_EXT_fragment_shader_interlock";
pub const VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION: u32 = 1;
pub const VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME: &CStr = c"VK_EXT_frame_boundary";
pub const VK_EXT_FRAME_BOUNDARY_SPEC_VERSION: u32 = 1;
pub const VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME: &CStr = c"VK_EXT_global_priority";
pub const VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME: &CStr = c"VK_EXT_global_priority_query";
pub const VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION: u32 = 1;
pub const VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION: u32 = 2;
pub const VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME: &CStr = c"VK_EXT_graphics_pipeline_library";
pub const VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION: u32 = 1;
pub const VK_EXT_HDR_METADATA_EXTENSION_NAME: &CStr = c"VK_EXT_hdr_metadata";
pub const VK_EXT_HDR_METADATA_SPEC_VERSION: u32 = 3;
pub const VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME: &CStr = c"VK_EXT_headless_surface";
pub const VK_EXT_HEADLESS_SURFACE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME: &CStr = c"VK_EXT_host_image_copy";
pub const VK_EXT_HOST_IMAGE_COPY_SPEC_VERSION: u32 = 1;
pub const VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME: &CStr = c"VK_EXT_host_query_reset";
pub const VK_EXT_HOST_QUERY_RESET_SPEC_VERSION: u32 = 1;
pub const VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME: &CStr = c"VK_EXT_image_2d_view_of_3d";
pub const VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION: u32 = 1;
pub const VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_image_compression_control";
pub const VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION: u32 = 1;
pub const VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME: &CStr = c"VK_EXT_image_compression_control_swapchain";
pub const VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION: u32 = 1;
pub const VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME: &CStr = c"VK_EXT_image_drm_format_modifier";
pub const VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION: u32 = 2;
pub const VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME: &CStr = c"VK_EXT_image_robustness";
pub const VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION: u32 = 1;
pub const VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME: &CStr = c"VK_EXT_image_sliced_view_of_3d";
pub const VK_EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION: u32 = 1;
pub const VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME: &CStr = c"VK_EXT_image_view_min_lod";
pub const VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION: u32 = 1;
pub const VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME: &CStr = c"VK_EXT_index_type_uint8";
pub const VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION: u32 = 1;
pub const VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME: &CStr = c"VK_EXT_inline_uniform_block";
pub const VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION: u32 = 1;
pub const VK_EXT_LAYER_SETTINGS_EXTENSION_NAME: &CStr = c"VK_EXT_layer_settings";
pub const VK_EXT_LAYER_SETTINGS_SPEC_VERSION: u32 = 2;
pub const VK_EXT_LEGACY_DITHERING_EXTENSION_NAME: &CStr = c"VK_EXT_legacy_dithering";
pub const VK_EXT_LEGACY_DITHERING_SPEC_VERSION: u32 = 2;
pub const VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME: &CStr = c"VK_EXT_legacy_vertex_attributes";
pub const VK_EXT_LEGACY_VERTEX_ATTRIBUTES_SPEC_VERSION: u32 = 1;
pub const VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME: &CStr = c"VK_EXT_line_rasterization";
pub const VK_EXT_LINE_RASTERIZATION_SPEC_VERSION: u32 = 1;
pub const VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME: &CStr = c"VK_EXT_load_store_op_none";
pub const VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME: &CStr = c"VK_EXT_map_memory_placed";
pub const VK_EXT_MAP_MEMORY_PLACED_SPEC_VERSION: u32 = 1;
pub const VK_EXT_MEMORY_BUDGET_EXTENSION_NAME: &CStr = c"VK_EXT_memory_budget";
pub const VK_EXT_MEMORY_BUDGET_SPEC_VERSION: u32 = 1;
pub const VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME: &CStr = c"VK_EXT_memory_decompression";
pub const VK_EXT_MEMORY_DECOMPRESSION_SPEC_VERSION: u32 = 1;
pub const VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME: &CStr = c"VK_EXT_memory_priority";
pub const VK_EXT_MEMORY_PRIORITY_SPEC_VERSION: u32 = 1;
pub const VK_EXT_MESH_SHADER_EXTENSION_NAME: &CStr = c"VK_EXT_mesh_shader";
pub const VK_EXT_MESH_SHADER_SPEC_VERSION: u32 = 1;
pub const VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME: &CStr = c"VK_EXT_multisampled_render_to_single_sampled";
pub const VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION: u32 = 1;
pub const VK_EXT_MULTI_DRAW_EXTENSION_NAME: &CStr = c"VK_EXT_multi_draw";
pub const VK_EXT_MULTI_DRAW_SPEC_VERSION: u32 = 1;
pub const VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME: &CStr = c"VK_EXT_mutable_descriptor_type";
pub const VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME: &CStr = c"VK_EXT_nested_command_buffer";
pub const VK_EXT_NESTED_COMMAND_BUFFER_SPEC_VERSION: u32 = 1;
pub const VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME: &CStr = c"VK_EXT_non_seamless_cube_map";
pub const VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION: u32 = 1;
pub const VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME: &CStr = c"VK_EXT_opacity_micromap";
pub const VK_EXT_OPACITY_MICROMAP_SPEC_VERSION: u32 = 2;
pub const VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME: &CStr = c"VK_EXT_pageable_device_local_memory";
pub const VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION: u32 = 1;
pub const VK_EXT_PCI_BUS_INFO_EXTENSION_NAME: &CStr = c"VK_EXT_pci_bus_info";
pub const VK_EXT_PCI_BUS_INFO_SPEC_VERSION: u32 = 2;
pub const VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME: &CStr = c"VK_EXT_physical_device_drm";
pub const VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION: u32 = 1;
pub const VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_creation_cache_control";
pub const VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION: u32 = 3;
pub const VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_creation_feedback";
pub const VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION: u32 = 1;
pub const VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_library_group_handles";
pub const VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION: u32 = 1;
pub const VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_properties";
pub const VK_EXT_PIPELINE_PROPERTIES_SPEC_VERSION: u32 = 1;
pub const VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_protected_access";
pub const VK_EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION: u32 = 1;
pub const VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_robustness";
pub const VK_EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION: u32 = 1;
pub const VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME: &CStr = c"VK_EXT_post_depth_coverage";
pub const VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME: &CStr = c"VK_EXT_present_mode_fifo_latest_ready";
pub const VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION: u32 = 1;
pub const VK_EXT_PRESENT_TIMING_EXTENSION_NAME: &CStr = c"VK_EXT_present_timing";
pub const VK_EXT_PRESENT_TIMING_SPEC_VERSION: u32 = 3;
pub const VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME: &CStr = c"VK_EXT_primitives_generated_query";
pub const VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION: u32 = 1;
pub const VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME: &CStr = c"VK_EXT_primitive_topology_list_restart";
pub const VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION: u32 = 1;
pub const VK_EXT_PRIVATE_DATA_EXTENSION_NAME: &CStr = c"VK_EXT_private_data";
pub const VK_EXT_PRIVATE_DATA_SPEC_VERSION: u32 = 1;
pub const VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME: &CStr = c"VK_EXT_provoking_vertex";
pub const VK_EXT_PROVOKING_VERTEX_SPEC_VERSION: u32 = 1;
pub const VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME: &CStr = c"VK_EXT_queue_family_foreign";
pub const VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION: u32 = 1;
pub const VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME: &CStr = c"VK_EXT_rasterization_order_attachment_access";
pub const VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION: u32 = 1;
pub const VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME: &CStr = c"VK_EXT_ray_tracing_invocation_reorder";
pub const VK_EXT_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION: u32 = 1;
pub const VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME: &CStr = c"VK_EXT_rgba10x6_formats";
pub const VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION: u32 = 1;
pub const VK_EXT_ROBUSTNESS_2_EXTENSION_NAME: &CStr = c"VK_EXT_robustness2";
pub const VK_EXT_ROBUSTNESS_2_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME: &CStr = c"VK_EXT_sampler_filter_minmax";
pub const VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION: u32 = 2;
pub const VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME: &CStr = c"VK_EXT_sample_locations";
pub const VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME: &CStr = c"VK_EXT_scalar_block_layout";
pub const VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME: &CStr = c"VK_EXT_separate_stencil_usage";
pub const VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME: &CStr = c"VK_EXT_shader_64bit_indexing";
pub const VK_EXT_SHADER_64BIT_INDEXING_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME: &CStr = c"VK_EXT_shader_atomic_float2";
pub const VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME: &CStr = c"VK_EXT_shader_atomic_float";
pub const VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME: &CStr = c"VK_EXT_shader_demote_to_helper_invocation";
pub const VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SHADER_FLOAT8_EXTENSION_NAME: &CStr = c"VK_EXT_shader_float8";
pub const VK_EXT_SHADER_FLOAT8_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME: &CStr = c"VK_EXT_shader_image_atomic_int64";
pub const VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME: &CStr = c"VK_EXT_shader_long_vector";
pub const VK_EXT_SHADER_LONG_VECTOR_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME: &CStr = c"VK_EXT_shader_module_identifier";
pub const VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SHADER_OBJECT_EXTENSION_NAME: &CStr = c"VK_EXT_shader_object";
pub const VK_EXT_SHADER_OBJECT_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME: &CStr = c"VK_EXT_shader_replicated_composites";
pub const VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME: &CStr = c"VK_EXT_shader_stencil_export";
pub const VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME: &CStr = c"VK_EXT_shader_subgroup_ballot";
pub const VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME: &CStr = c"VK_EXT_shader_subgroup_vote";
pub const VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME: &CStr = c"VK_EXT_shader_tile_image";
pub const VK_EXT_SHADER_TILE_IMAGE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_EXTENSION_NAME: &CStr = c"VK_EXT_shader_uniform_buffer_unsized_array";
pub const VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME: &CStr = c"VK_EXT_shader_viewport_index_layer";
pub const VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_subgroup_size_control";
pub const VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION: u32 = 2;
pub const VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME: &CStr = c"VK_EXT_subpass_merge_feedback";
pub const VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION: u32 = 2;
pub const VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_EXT_surface_maintenance1";
pub const VK_EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
pub const VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME: &CStr = c"VK_EXT_swapchain_colorspace";
pub const VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION: u32 = 5;
pub const VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_EXT_swapchain_maintenance1";
pub const VK_EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
pub const VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME: &CStr = c"VK_EXT_texel_buffer_alignment";
pub const VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION: u32 = 1;
pub const VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_EXTENSION_NAME: &CStr = c"VK_EXT_texture_compression_astc_3d";
pub const VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_SPEC_VERSION: u32 = 1;
pub const VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME: &CStr = c"VK_EXT_texture_compression_astc_hdr";
pub const VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION: u32 = 1;
pub const VK_EXT_TOOLING_INFO_EXTENSION_NAME: &CStr = c"VK_EXT_tooling_info";
pub const VK_EXT_TOOLING_INFO_SPEC_VERSION: u32 = 1;
pub const VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME: &CStr = c"VK_EXT_transform_feedback";
pub const VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION: u32 = 1;
pub const VK_EXT_VALIDATION_CACHE_EXTENSION_NAME: &CStr = c"VK_EXT_validation_cache";
pub const VK_EXT_VALIDATION_CACHE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME: &CStr = c"VK_EXT_validation_features";
pub const VK_EXT_VALIDATION_FEATURES_SPEC_VERSION: u32 = 6;
pub const VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME: &CStr = c"VK_EXT_validation_flags";
pub const VK_EXT_VALIDATION_FLAGS_SPEC_VERSION: u32 = 3;
pub const VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME: &CStr = c"VK_EXT_vertex_attribute_divisor";
pub const VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION: u32 = 3;
pub const VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME: &CStr = c"VK_EXT_vertex_attribute_robustness";
pub const VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION: u32 = 1;
pub const VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME: &CStr = c"VK_EXT_vertex_input_dynamic_state";
pub const VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION: u32 = 2;
pub const VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME: &CStr = c"VK_EXT_ycbcr_2plane_444_formats";
pub const VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION: u32 = 1;
pub const VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME: &CStr = c"VK_EXT_ycbcr_image_arrays";
pub const VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION: u32 = 1;
pub const VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_EXTENSION_NAME: &CStr = c"VK_EXT_zero_initialize_device_memory";
pub const VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_SPEC_VERSION: u32 = 1;
pub const VK_FALSE: u32 = 0;
pub const VK_FENCE_CREATE_SIGNALED_BIT: VkFenceCreateFlagBits = 1 << 0;
pub const VK_FENCE_IMPORT_TEMPORARY_BIT: VkFenceImportFlagBits = 1 << 0;
pub const VK_FENCE_IMPORT_TEMPORARY_BIT_KHR: VkFenceImportFlagBits = VK_FENCE_IMPORT_TEMPORARY_BIT;
pub const VK_FILTER_CUBIC_EXT: VkFilter = 1000015000;
pub const VK_FILTER_CUBIC_IMG: VkFilter = VK_FILTER_CUBIC_EXT;
pub const VK_FILTER_LINEAR: VkFilter = 1;
pub const VK_FILTER_NEAREST: VkFilter = 0;
pub const VK_FORMAT_A1B5G5R5_UNORM_PACK16: VkFormat = 1000470000;
pub const VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR: VkFormat = VK_FORMAT_A1B5G5R5_UNORM_PACK16;
pub const VK_FORMAT_A1R5G5B5_UNORM_PACK16: VkFormat = 8;
pub const VK_FORMAT_A2B10G10R10_SINT_PACK32: VkFormat = 69;
pub const VK_FORMAT_A2B10G10R10_SNORM_PACK32: VkFormat = 65;
pub const VK_FORMAT_A2B10G10R10_SSCALED_PACK32: VkFormat = 67;
pub const VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormat = 68;
pub const VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormat = 64;
pub const VK_FORMAT_A2B10G10R10_USCALED_PACK32: VkFormat = 66;
pub const VK_FORMAT_A2R10G10B10_SINT_PACK32: VkFormat = 63;
pub const VK_FORMAT_A2R10G10B10_SNORM_PACK32: VkFormat = 59;
pub const VK_FORMAT_A2R10G10B10_SSCALED_PACK32: VkFormat = 61;
pub const VK_FORMAT_A2R10G10B10_UINT_PACK32: VkFormat = 62;
pub const VK_FORMAT_A2R10G10B10_UNORM_PACK32: VkFormat = 58;
pub const VK_FORMAT_A2R10G10B10_USCALED_PACK32: VkFormat = 60;
pub const VK_FORMAT_A4B4G4R4_UNORM_PACK16: VkFormat = 1000340001;
pub const VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT: VkFormat = VK_FORMAT_A4B4G4R4_UNORM_PACK16;
pub const VK_FORMAT_A4R4G4B4_UNORM_PACK16: VkFormat = 1000340000;
pub const VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT: VkFormat = VK_FORMAT_A4R4G4B4_UNORM_PACK16;
pub const VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormat = 56;
pub const VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormat = 52;
pub const VK_FORMAT_A8B8G8R8_SRGB_PACK32: VkFormat = 57;
pub const VK_FORMAT_A8B8G8R8_SSCALED_PACK32: VkFormat = 54;
pub const VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormat = 55;
pub const VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormat = 51;
pub const VK_FORMAT_A8B8G8R8_USCALED_PACK32: VkFormat = 53;
pub const VK_FORMAT_A8_UNORM: VkFormat = 1000470001;
pub const VK_FORMAT_A8_UNORM_KHR: VkFormat = VK_FORMAT_A8_UNORM;
pub const VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK: VkFormat = 1000066011;
pub const VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK;
pub const VK_FORMAT_ASTC_10x10_SRGB_BLOCK: VkFormat = 180;
pub const VK_FORMAT_ASTC_10x10_UNORM_BLOCK: VkFormat = 179;
pub const VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK: VkFormat = 1000066008;
pub const VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK;
pub const VK_FORMAT_ASTC_10x5_SRGB_BLOCK: VkFormat = 174;
pub const VK_FORMAT_ASTC_10x5_UNORM_BLOCK: VkFormat = 173;
pub const VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK: VkFormat = 1000066009;
pub const VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK;
pub const VK_FORMAT_ASTC_10x6_SRGB_BLOCK: VkFormat = 176;
pub const VK_FORMAT_ASTC_10x6_UNORM_BLOCK: VkFormat = 175;
pub const VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK: VkFormat = 1000066010;
pub const VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK;
pub const VK_FORMAT_ASTC_10x8_SRGB_BLOCK: VkFormat = 178;
pub const VK_FORMAT_ASTC_10x8_UNORM_BLOCK: VkFormat = 177;
pub const VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK: VkFormat = 1000066012;
pub const VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK;
pub const VK_FORMAT_ASTC_12x10_SRGB_BLOCK: VkFormat = 182;
pub const VK_FORMAT_ASTC_12x10_UNORM_BLOCK: VkFormat = 181;
pub const VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK: VkFormat = 1000066013;
pub const VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK;
pub const VK_FORMAT_ASTC_12x12_SRGB_BLOCK: VkFormat = 184;
pub const VK_FORMAT_ASTC_12x12_UNORM_BLOCK: VkFormat = 183;
pub const VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT: VkFormat = 1000288002;
pub const VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT: VkFormat = 1000288001;
pub const VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT: VkFormat = 1000288000;
pub const VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT: VkFormat = 1000288005;
pub const VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT: VkFormat = 1000288004;
pub const VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT: VkFormat = 1000288003;
pub const VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK: VkFormat = 1000066000;
pub const VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK;
pub const VK_FORMAT_ASTC_4x4_SRGB_BLOCK: VkFormat = 158;
pub const VK_FORMAT_ASTC_4x4_UNORM_BLOCK: VkFormat = 157;
pub const VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT: VkFormat = 1000288008;
pub const VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT: VkFormat = 1000288007;
pub const VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT: VkFormat = 1000288006;
pub const VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT: VkFormat = 1000288011;
pub const VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT: VkFormat = 1000288010;
pub const VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT: VkFormat = 1000288009;
pub const VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK: VkFormat = 1000066001;
pub const VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK;
pub const VK_FORMAT_ASTC_5x4_SRGB_BLOCK: VkFormat = 160;
pub const VK_FORMAT_ASTC_5x4_UNORM_BLOCK: VkFormat = 159;
pub const VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT: VkFormat = 1000288014;
pub const VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT: VkFormat = 1000288013;
pub const VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT: VkFormat = 1000288012;
pub const VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK: VkFormat = 1000066002;
pub const VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK;
pub const VK_FORMAT_ASTC_5x5_SRGB_BLOCK: VkFormat = 162;
pub const VK_FORMAT_ASTC_5x5_UNORM_BLOCK: VkFormat = 161;
pub const VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT: VkFormat = 1000288017;
pub const VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT: VkFormat = 1000288016;
pub const VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT: VkFormat = 1000288015;
pub const VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT: VkFormat = 1000288020;
pub const VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT: VkFormat = 1000288019;
pub const VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT: VkFormat = 1000288018;
pub const VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK: VkFormat = 1000066003;
pub const VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK;
pub const VK_FORMAT_ASTC_6x5_SRGB_BLOCK: VkFormat = 164;
pub const VK_FORMAT_ASTC_6x5_UNORM_BLOCK: VkFormat = 163;
pub const VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT: VkFormat = 1000288023;
pub const VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT: VkFormat = 1000288022;
pub const VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT: VkFormat = 1000288021;
pub const VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK: VkFormat = 1000066004;
pub const VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK;
pub const VK_FORMAT_ASTC_6x6_SRGB_BLOCK: VkFormat = 166;
pub const VK_FORMAT_ASTC_6x6_UNORM_BLOCK: VkFormat = 165;
pub const VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT: VkFormat = 1000288026;
pub const VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT: VkFormat = 1000288025;
pub const VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT: VkFormat = 1000288024;
pub const VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT: VkFormat = 1000288029;
pub const VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT: VkFormat = 1000288028;
pub const VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT: VkFormat = 1000288027;
pub const VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK: VkFormat = 1000066005;
pub const VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK;
pub const VK_FORMAT_ASTC_8x5_SRGB_BLOCK: VkFormat = 168;
pub const VK_FORMAT_ASTC_8x5_UNORM_BLOCK: VkFormat = 167;
pub const VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK: VkFormat = 1000066006;
pub const VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK;
pub const VK_FORMAT_ASTC_8x6_SRGB_BLOCK: VkFormat = 170;
pub const VK_FORMAT_ASTC_8x6_UNORM_BLOCK: VkFormat = 169;
pub const VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK: VkFormat = 1000066007;
pub const VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK;
pub const VK_FORMAT_ASTC_8x8_SRGB_BLOCK: VkFormat = 172;
pub const VK_FORMAT_ASTC_8x8_UNORM_BLOCK: VkFormat = 171;
pub const VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormat = 122;
pub const VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: VkFormat = 1000156011;
pub const VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16;
pub const VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: VkFormat = 1000156021;
pub const VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16;
pub const VK_FORMAT_B16G16R16G16_422_UNORM: VkFormat = 1000156028;
pub const VK_FORMAT_B16G16R16G16_422_UNORM_KHR: VkFormat = VK_FORMAT_B16G16R16G16_422_UNORM;
pub const VK_FORMAT_B4G4R4A4_UNORM_PACK16: VkFormat = 3;
pub const VK_FORMAT_B5G5R5A1_UNORM_PACK16: VkFormat = 7;
pub const VK_FORMAT_B5G6R5_UNORM_PACK16: VkFormat = 5;
pub const VK_FORMAT_B8G8R8A8_SINT: VkFormat = 49;
pub const VK_FORMAT_B8G8R8A8_SNORM: VkFormat = 45;
pub const VK_FORMAT_B8G8R8A8_SRGB: VkFormat = 50;
pub const VK_FORMAT_B8G8R8A8_SSCALED: VkFormat = 47;
pub const VK_FORMAT_B8G8R8A8_UINT: VkFormat = 48;
pub const VK_FORMAT_B8G8R8A8_UNORM: VkFormat = 44;
pub const VK_FORMAT_B8G8R8A8_USCALED: VkFormat = 46;
pub const VK_FORMAT_B8G8R8G8_422_UNORM: VkFormat = 1000156001;
pub const VK_FORMAT_B8G8R8G8_422_UNORM_KHR: VkFormat = VK_FORMAT_B8G8R8G8_422_UNORM;
pub const VK_FORMAT_B8G8R8_SINT: VkFormat = 35;
pub const VK_FORMAT_B8G8R8_SNORM: VkFormat = 31;
pub const VK_FORMAT_B8G8R8_SRGB: VkFormat = 36;
pub const VK_FORMAT_B8G8R8_SSCALED: VkFormat = 33;
pub const VK_FORMAT_B8G8R8_UINT: VkFormat = 34;
pub const VK_FORMAT_B8G8R8_UNORM: VkFormat = 30;
pub const VK_FORMAT_B8G8R8_USCALED: VkFormat = 32;
pub const VK_FORMAT_BC1_RGBA_SRGB_BLOCK: VkFormat = 134;
pub const VK_FORMAT_BC1_RGBA_UNORM_BLOCK: VkFormat = 133;
pub const VK_FORMAT_BC1_RGB_SRGB_BLOCK: VkFormat = 132;
pub const VK_FORMAT_BC1_RGB_UNORM_BLOCK: VkFormat = 131;
pub const VK_FORMAT_BC2_SRGB_BLOCK: VkFormat = 136;
pub const VK_FORMAT_BC2_UNORM_BLOCK: VkFormat = 135;
pub const VK_FORMAT_BC3_SRGB_BLOCK: VkFormat = 138;
pub const VK_FORMAT_BC3_UNORM_BLOCK: VkFormat = 137;
pub const VK_FORMAT_BC4_SNORM_BLOCK: VkFormat = 140;
pub const VK_FORMAT_BC4_UNORM_BLOCK: VkFormat = 139;
pub const VK_FORMAT_BC5_SNORM_BLOCK: VkFormat = 142;
pub const VK_FORMAT_BC5_UNORM_BLOCK: VkFormat = 141;
pub const VK_FORMAT_BC6H_SFLOAT_BLOCK: VkFormat = 144;
pub const VK_FORMAT_BC6H_UFLOAT_BLOCK: VkFormat = 143;
pub const VK_FORMAT_BC7_SRGB_BLOCK: VkFormat = 146;
pub const VK_FORMAT_BC7_UNORM_BLOCK: VkFormat = 145;
pub const VK_FORMAT_D16_UNORM: VkFormat = 124;
pub const VK_FORMAT_D16_UNORM_S8_UINT: VkFormat = 128;
pub const VK_FORMAT_D24_UNORM_S8_UINT: VkFormat = 129;
pub const VK_FORMAT_D32_SFLOAT: VkFormat = 126;
pub const VK_FORMAT_D32_SFLOAT_S8_UINT: VkFormat = 130;
pub const VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: VkFormat = 123;
pub const VK_FORMAT_EAC_R11G11_SNORM_BLOCK: VkFormat = 156;
pub const VK_FORMAT_EAC_R11G11_UNORM_BLOCK: VkFormat = 155;
pub const VK_FORMAT_EAC_R11_SNORM_BLOCK: VkFormat = 154;
pub const VK_FORMAT_EAC_R11_UNORM_BLOCK: VkFormat = 153;
pub const VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: VkFormat = 150;
pub const VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: VkFormat = 149;
pub const VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: VkFormat = 152;
pub const VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: VkFormat = 151;
pub const VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: VkFormat = 148;
pub const VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: VkFormat = 147;
pub const VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV: VkFormatFeatureFlagBits2 = 1 << 51;
pub const VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 29;
pub const VK_FORMAT_FEATURE_2_BLIT_DST_BIT: VkFormatFeatureFlagBits2 = 1 << 11;
pub const VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_BLIT_DST_BIT;
pub const VK_FORMAT_FEATURE_2_BLIT_SRC_BIT: VkFormatFeatureFlagBits2 = 1 << 10;
pub const VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_BLIT_SRC_BIT;
pub const VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM: VkFormatFeatureFlagBits2 = 1 << 36;
pub const VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM: VkFormatFeatureFlagBits2 = 1 << 37;
pub const VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT: VkFormatFeatureFlagBits2 = 1 << 7;
pub const VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT;
pub const VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT: VkFormatFeatureFlagBits2 = 1 << 8;
pub const VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT;
pub const VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 59;
pub const VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT: VkFormatFeatureFlagBits2 = 1 << 23;
pub const VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT;
pub const VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 52;
pub const VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 53;
pub const VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT: VkFormatFeatureFlagBits2 = 1 << 9;
pub const VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT;
pub const VK_FORMAT_FEATURE_2_DISJOINT_BIT: VkFormatFeatureFlagBits2 = 1 << 22;
pub const VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_DISJOINT_BIT;
pub const VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT: VkFormatFeatureFlagBits2 = 1 << 24;
pub const VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 30;
pub const VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT: VkFormatFeatureFlagBits2 = 1 << 46;
pub const VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT;
pub const VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV: VkFormatFeatureFlagBits2 = 1 << 38;
pub const VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT: VkFormatFeatureFlagBits2 = 1 << 17;
pub const VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT;
pub const VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV: VkFormatFeatureFlagBits2 = 1 << 42;
pub const VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV: VkFormatFeatureFlagBits2 = 1 << 40;
pub const VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV: VkFormatFeatureFlagBits2 = 1 << 41;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT: VkFormatFeatureFlagBits2 = 1 << 0;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT: VkFormatFeatureFlagBits2 = 1 << 33;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT: VkFormatFeatureFlagBits2 = 1 << 13;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT: VkFormatFeatureFlagBits2 = 1 << 12;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT: VkFormatFeatureFlagBits2 = 1 << 16;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT: VkFormatFeatureFlagBits2 = 1 << 20;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR: VkFormatFeatureFlagBits2 = 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_FORCEABLE_BIT: VkFormatFeatureFlagBits2 = 1 << 21;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT: VkFormatFeatureFlagBits2 = 1 << 18;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT: VkFormatFeatureFlagBits2 = 1 << 19;
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT;
pub const VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 54;
pub const VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 55;
pub const VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT: VkFormatFeatureFlagBits2 = 1 << 2;
pub const VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT;
pub const VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT: VkFormatFeatureFlagBits2 = 1 << 1;
pub const VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT;
pub const VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT: VkFormatFeatureFlagBits2 = 1 << 31;
pub const VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT;
pub const VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT: VkFormatFeatureFlagBits2 = 1 << 5;
pub const VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT;
pub const VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT: VkFormatFeatureFlagBits2 = 1 << 4;
pub const VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT;
pub const VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT: VkFormatFeatureFlagBits2 = 1 << 32;
pub const VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT;
pub const VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM: VkFormatFeatureFlagBits2 = 1 << 48;
pub const VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM: VkFormatFeatureFlagBits2 = 1 << 43;
pub const VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM: VkFormatFeatureFlagBits2 = 1 << 39;
pub const VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT: VkFormatFeatureFlagBits2 = 1 << 15;
pub const VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT;
pub const VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT: VkFormatFeatureFlagBits2 = 1 << 14;
pub const VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT;
pub const VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT: VkFormatFeatureFlagBits2 = 1 << 3;
pub const VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT;
pub const VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT: VkFormatFeatureFlagBits2 = 1 << 6;
pub const VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT;
pub const VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 26;
pub const VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 25;
pub const VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 28;
pub const VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 50;
pub const VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 27;
pub const VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 49;
pub const VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM: VkFormatFeatureFlagBits2 = 1 << 34;
pub const VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM: VkFormatFeatureFlagBits2 = 1 << 35;
pub const VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR: VkFormatFeatureFlagBits = 1 << 29;
pub const VK_FORMAT_FEATURE_BLIT_DST_BIT: VkFormatFeatureFlagBits = 1 << 11;
pub const VK_FORMAT_FEATURE_BLIT_SRC_BIT: VkFormatFeatureFlagBits = 1 << 10;
pub const VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT: VkFormatFeatureFlagBits = 1 << 7;
pub const VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT: VkFormatFeatureFlagBits = 1 << 8;
pub const VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT: VkFormatFeatureFlagBits = 1 << 23;
pub const VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT;
pub const VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT: VkFormatFeatureFlagBits = 1 << 9;
pub const VK_FORMAT_FEATURE_DISJOINT_BIT: VkFormatFeatureFlagBits = 1 << 22;
pub const VK_FORMAT_FEATURE_DISJOINT_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_DISJOINT_BIT;
pub const VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT: VkFormatFeatureFlagBits = 1 << 24;
pub const VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkFormatFeatureFlagBits = 1 << 30;
pub const VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT: VkFormatFeatureFlagBits = 1 << 17;
pub const VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT;
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT: VkFormatFeatureFlagBits = 1 << 0;
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT: VkFormatFeatureFlagBits = 1 << 13;
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT;
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT: VkFormatFeatureFlagBits = 1 << 12;
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT: VkFormatFeatureFlagBits = 1 << 16;
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT;
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT: VkFormatFeatureFlagBits = 1 << 20;
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT;
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT: VkFormatFeatureFlagBits = 1 << 21;
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT;
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT: VkFormatFeatureFlagBits = 1 << 18;
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT;
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT: VkFormatFeatureFlagBits = 1 << 19;
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT;
pub const VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT: VkFormatFeatureFlagBits = 1 << 2;
pub const VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT: VkFormatFeatureFlagBits = 1 << 1;
pub const VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT: VkFormatFeatureFlagBits = 1 << 5;
pub const VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT: VkFormatFeatureFlagBits = 1 << 4;
pub const VK_FORMAT_FEATURE_TRANSFER_DST_BIT: VkFormatFeatureFlagBits = 1 << 15;
pub const VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
pub const VK_FORMAT_FEATURE_TRANSFER_SRC_BIT: VkFormatFeatureFlagBits = 1 << 14;
pub const VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT;
pub const VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT: VkFormatFeatureFlagBits = 1 << 3;
pub const VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT: VkFormatFeatureFlagBits = 1 << 6;
pub const VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR: VkFormatFeatureFlagBits = 1 << 26;
pub const VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR: VkFormatFeatureFlagBits = 1 << 25;
pub const VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR: VkFormatFeatureFlagBits = 1 << 28;
pub const VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR: VkFormatFeatureFlagBits = 1 << 27;
pub const VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: VkFormat = 1000156010;
pub const VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16;
pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: VkFormat = 1000156013;
pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16;
pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: VkFormat = 1000156015;
pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16;
pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16: VkFormat = 1000330001;
pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT: VkFormat = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16;
pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: VkFormat = 1000156012;
pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16;
pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: VkFormat = 1000156014;
pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16;
pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: VkFormat = 1000156016;
pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16;
pub const VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: VkFormat = 1000156020;
pub const VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16;
pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: VkFormat = 1000156023;
pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16;
pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: VkFormat = 1000156025;
pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16;
pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16: VkFormat = 1000330002;
pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT: VkFormat = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16;
pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: VkFormat = 1000156022;
pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16;
pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: VkFormat = 1000156024;
pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16;
pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: VkFormat = 1000156026;
pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16;
pub const VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM: VkFormat = 1000609012;
pub const VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM: VkFormat = 1000609013;
pub const VK_FORMAT_G16B16G16R16_422_UNORM: VkFormat = 1000156027;
pub const VK_FORMAT_G16B16G16R16_422_UNORM_KHR: VkFormat = VK_FORMAT_G16B16G16R16_422_UNORM;
pub const VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: VkFormat = 1000156030;
pub const VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM;
pub const VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: VkFormat = 1000156032;
pub const VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM;
pub const VK_FORMAT_G16_B16R16_2PLANE_444_UNORM: VkFormat = 1000330003;
pub const VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT: VkFormat = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM;
pub const VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: VkFormat = 1000156029;
pub const VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM;
pub const VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: VkFormat = 1000156031;
pub const VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM;
pub const VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: VkFormat = 1000156033;
pub const VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM;
pub const VK_FORMAT_G8B8G8R8_422_UNORM: VkFormat = 1000156000;
pub const VK_FORMAT_G8B8G8R8_422_UNORM_KHR: VkFormat = VK_FORMAT_G8B8G8R8_422_UNORM;
pub const VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: VkFormat = 1000156003;
pub const VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
pub const VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: VkFormat = 1000156005;
pub const VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM;
pub const VK_FORMAT_G8_B8R8_2PLANE_444_UNORM: VkFormat = 1000330000;
pub const VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT: VkFormat = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM;
pub const VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: VkFormat = 1000156002;
pub const VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM;
pub const VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: VkFormat = 1000156004;
pub const VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM;
pub const VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: VkFormat = 1000156006;
pub const VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM;
pub const VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: VkFormat = 1000054004;
pub const VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: VkFormat = 1000054000;
pub const VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: VkFormat = 1000054005;
pub const VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: VkFormat = 1000054001;
pub const VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: VkFormat = 1000054006;
pub const VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: VkFormat = 1000054002;
pub const VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: VkFormat = 1000054007;
pub const VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: VkFormat = 1000054003;
pub const VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM: VkFormat = 1000609002;
pub const VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: VkFormat = 1000156009;
pub const VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16;
pub const VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM: VkFormat = 1000609001;
pub const VK_FORMAT_R10X6G10X6_UNORM_2PACK16: VkFormat = 1000156008;
pub const VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR: VkFormat = VK_FORMAT_R10X6G10X6_UNORM_2PACK16;
pub const VK_FORMAT_R10X6_UINT_PACK16_ARM: VkFormat = 1000609000;
pub const VK_FORMAT_R10X6_UNORM_PACK16: VkFormat = 1000156007;
pub const VK_FORMAT_R10X6_UNORM_PACK16_KHR: VkFormat = VK_FORMAT_R10X6_UNORM_PACK16;
pub const VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM: VkFormat = 1000609005;
pub const VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: VkFormat = 1000156019;
pub const VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16;
pub const VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM: VkFormat = 1000609004;
pub const VK_FORMAT_R12X4G12X4_UNORM_2PACK16: VkFormat = 1000156018;
pub const VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR: VkFormat = VK_FORMAT_R12X4G12X4_UNORM_2PACK16;
pub const VK_FORMAT_R12X4_UINT_PACK16_ARM: VkFormat = 1000609003;
pub const VK_FORMAT_R12X4_UNORM_PACK16: VkFormat = 1000156017;
pub const VK_FORMAT_R12X4_UNORM_PACK16_KHR: VkFormat = VK_FORMAT_R12X4_UNORM_PACK16;
pub const VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM: VkFormat = 1000609008;
pub const VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM: VkFormat = 1000609011;
pub const VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM: VkFormat = 1000609007;
pub const VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM: VkFormat = 1000609010;
pub const VK_FORMAT_R14X2_UINT_PACK16_ARM: VkFormat = 1000609006;
pub const VK_FORMAT_R14X2_UNORM_PACK16_ARM: VkFormat = 1000609009;
pub const VK_FORMAT_R16G16B16A16_SFLOAT: VkFormat = 97;
pub const VK_FORMAT_R16G16B16A16_SINT: VkFormat = 96;
pub const VK_FORMAT_R16G16B16A16_SNORM: VkFormat = 92;
pub const VK_FORMAT_R16G16B16A16_SSCALED: VkFormat = 94;
pub const VK_FORMAT_R16G16B16A16_UINT: VkFormat = 95;
pub const VK_FORMAT_R16G16B16A16_UNORM: VkFormat = 91;
pub const VK_FORMAT_R16G16B16A16_USCALED: VkFormat = 93;
pub const VK_FORMAT_R16G16B16_SFLOAT: VkFormat = 90;
pub const VK_FORMAT_R16G16B16_SINT: VkFormat = 89;
pub const VK_FORMAT_R16G16B16_SNORM: VkFormat = 85;
pub const VK_FORMAT_R16G16B16_SSCALED: VkFormat = 87;
pub const VK_FORMAT_R16G16B16_UINT: VkFormat = 88;
pub const VK_FORMAT_R16G16B16_UNORM: VkFormat = 84;
pub const VK_FORMAT_R16G16B16_USCALED: VkFormat = 86;
pub const VK_FORMAT_R16G16_S10_5_NV: VkFormat = VK_FORMAT_R16G16_SFIXED5_NV;
pub const VK_FORMAT_R16G16_SFIXED5_NV: VkFormat = 1000464000;
pub const VK_FORMAT_R16G16_SFLOAT: VkFormat = 83;
pub const VK_FORMAT_R16G16_SINT: VkFormat = 82;
pub const VK_FORMAT_R16G16_SNORM: VkFormat = 78;
pub const VK_FORMAT_R16G16_SSCALED: VkFormat = 80;
pub const VK_FORMAT_R16G16_UINT: VkFormat = 81;
pub const VK_FORMAT_R16G16_UNORM: VkFormat = 77;
pub const VK_FORMAT_R16G16_USCALED: VkFormat = 79;
pub const VK_FORMAT_R16_SFLOAT: VkFormat = 76;
pub const VK_FORMAT_R16_SINT: VkFormat = 75;
pub const VK_FORMAT_R16_SNORM: VkFormat = 71;
pub const VK_FORMAT_R16_SSCALED: VkFormat = 73;
pub const VK_FORMAT_R16_UINT: VkFormat = 74;
pub const VK_FORMAT_R16_UNORM: VkFormat = 70;
pub const VK_FORMAT_R16_USCALED: VkFormat = 72;
pub const VK_FORMAT_R32G32B32A32_SFLOAT: VkFormat = 109;
pub const VK_FORMAT_R32G32B32A32_SINT: VkFormat = 108;
pub const VK_FORMAT_R32G32B32A32_UINT: VkFormat = 107;
pub const VK_FORMAT_R32G32B32_SFLOAT: VkFormat = 106;
pub const VK_FORMAT_R32G32B32_SINT: VkFormat = 105;
pub const VK_FORMAT_R32G32B32_UINT: VkFormat = 104;
pub const VK_FORMAT_R32G32_SFLOAT: VkFormat = 103;
pub const VK_FORMAT_R32G32_SINT: VkFormat = 102;
pub const VK_FORMAT_R32G32_UINT: VkFormat = 101;
pub const VK_FORMAT_R32_SFLOAT: VkFormat = 100;
pub const VK_FORMAT_R32_SINT: VkFormat = 99;
pub const VK_FORMAT_R32_UINT: VkFormat = 98;
pub const VK_FORMAT_R4G4B4A4_UNORM_PACK16: VkFormat = 2;
pub const VK_FORMAT_R4G4_UNORM_PACK8: VkFormat = 1;
pub const VK_FORMAT_R5G5B5A1_UNORM_PACK16: VkFormat = 6;
pub const VK_FORMAT_R5G6B5_UNORM_PACK16: VkFormat = 4;
pub const VK_FORMAT_R64G64B64A64_SFLOAT: VkFormat = 121;
pub const VK_FORMAT_R64G64B64A64_SINT: VkFormat = 120;
pub const VK_FORMAT_R64G64B64A64_UINT: VkFormat = 119;
pub const VK_FORMAT_R64G64B64_SFLOAT: VkFormat = 118;
pub const VK_FORMAT_R64G64B64_SINT: VkFormat = 117;
pub const VK_FORMAT_R64G64B64_UINT: VkFormat = 116;
pub const VK_FORMAT_R64G64_SFLOAT: VkFormat = 115;
pub const VK_FORMAT_R64G64_SINT: VkFormat = 114;
pub const VK_FORMAT_R64G64_UINT: VkFormat = 113;
pub const VK_FORMAT_R64_SFLOAT: VkFormat = 112;
pub const VK_FORMAT_R64_SINT: VkFormat = 111;
pub const VK_FORMAT_R64_UINT: VkFormat = 110;
pub const VK_FORMAT_R8G8B8A8_SINT: VkFormat = 42;
pub const VK_FORMAT_R8G8B8A8_SNORM: VkFormat = 38;
pub const VK_FORMAT_R8G8B8A8_SRGB: VkFormat = 43;
pub const VK_FORMAT_R8G8B8A8_SSCALED: VkFormat = 40;
pub const VK_FORMAT_R8G8B8A8_UINT: VkFormat = 41;
pub const VK_FORMAT_R8G8B8A8_UNORM: VkFormat = 37;
pub const VK_FORMAT_R8G8B8A8_USCALED: VkFormat = 39;
pub const VK_FORMAT_R8G8B8_SINT: VkFormat = 28;
pub const VK_FORMAT_R8G8B8_SNORM: VkFormat = 24;
pub const VK_FORMAT_R8G8B8_SRGB: VkFormat = 29;
pub const VK_FORMAT_R8G8B8_SSCALED: VkFormat = 26;
pub const VK_FORMAT_R8G8B8_UINT: VkFormat = 27;
pub const VK_FORMAT_R8G8B8_UNORM: VkFormat = 23;
pub const VK_FORMAT_R8G8B8_USCALED: VkFormat = 25;
pub const VK_FORMAT_R8G8_SINT: VkFormat = 21;
pub const VK_FORMAT_R8G8_SNORM: VkFormat = 17;
pub const VK_FORMAT_R8G8_SRGB: VkFormat = 22;
pub const VK_FORMAT_R8G8_SSCALED: VkFormat = 19;
pub const VK_FORMAT_R8G8_UINT: VkFormat = 20;
pub const VK_FORMAT_R8G8_UNORM: VkFormat = 16;
pub const VK_FORMAT_R8G8_USCALED: VkFormat = 18;
pub const VK_FORMAT_R8_BOOL_ARM: VkFormat = 1000460000;
pub const VK_FORMAT_R8_SINT: VkFormat = 14;
pub const VK_FORMAT_R8_SNORM: VkFormat = 10;
pub const VK_FORMAT_R8_SRGB: VkFormat = 15;
pub const VK_FORMAT_R8_SSCALED: VkFormat = 12;
pub const VK_FORMAT_R8_UINT: VkFormat = 13;
pub const VK_FORMAT_R8_UNORM: VkFormat = 9;
pub const VK_FORMAT_R8_USCALED: VkFormat = 11;
pub const VK_FORMAT_S8_UINT: VkFormat = 127;
pub const VK_FORMAT_UNDEFINED: VkFormat = 0;
pub const VK_FORMAT_X8_D24_UNORM_PACK32: VkFormat = 125;
pub const VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV: VkFragmentShadingRateNV = 14;
pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV: VkFragmentShadingRateNV = 1;
pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV: VkFragmentShadingRateNV = 4;
pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV: VkFragmentShadingRateNV = 5;
pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV: VkFragmentShadingRateNV = 6;
pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV: VkFragmentShadingRateNV = 9;
pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV: VkFragmentShadingRateNV = 10;
pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV: VkFragmentShadingRateNV = 0;
pub const VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV: VkFragmentShadingRateNV = 11;
pub const VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV: VkFragmentShadingRateNV = 12;
pub const VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV: VkFragmentShadingRateNV = 13;
pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR: VkFragmentShadingRateCombinerOpKHR = 0;
pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR: VkFragmentShadingRateCombinerOpKHR = 3;
pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR: VkFragmentShadingRateCombinerOpKHR = 2;
pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR: VkFragmentShadingRateCombinerOpKHR = 4;
pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR: VkFragmentShadingRateCombinerOpKHR = 1;
pub const VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV: VkFragmentShadingRateNV = 15;
pub const VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV: VkFragmentShadingRateTypeNV = 1;
pub const VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV: VkFragmentShadingRateTypeNV = 0;
pub const VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT: VkFramebufferCreateFlagBits = 1 << 0;
pub const VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR: VkFramebufferCreateFlagBits = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT;
pub const VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT: VkFrameBoundaryFlagBitsEXT = 1 << 0;
pub const VK_FRONT_FACE_CLOCKWISE: VkFrontFace = 1;
pub const VK_FRONT_FACE_COUNTER_CLOCKWISE: VkFrontFace = 0;
pub const VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT: VkGeometryInstanceFlagBitsKHR = 1 << 5;
pub const VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT;
pub const VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR: VkGeometryInstanceFlagBitsKHR = 1 << 3;
pub const VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR;
pub const VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT: VkGeometryInstanceFlagBitsKHR = 1 << 4;
pub const VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT;
pub const VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR: VkGeometryInstanceFlagBitsKHR = 1 << 2;
pub const VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR;
pub const VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR;
pub const VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR: VkGeometryInstanceFlagBitsKHR = 1 << 0;
pub const VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR: VkGeometryInstanceFlagBitsKHR = 1 << 1;
pub const VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR;
pub const VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR;
pub const VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR: VkGeometryFlagBitsKHR = 1 << 1;
pub const VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV: VkGeometryFlagBitsKHR = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR;
pub const VK_GEOMETRY_OPAQUE_BIT_KHR: VkGeometryFlagBitsKHR = 1 << 0;
pub const VK_GEOMETRY_OPAQUE_BIT_NV: VkGeometryFlagBitsKHR = VK_GEOMETRY_OPAQUE_BIT_KHR;
pub const VK_GEOMETRY_TYPE_AABBS_KHR: VkGeometryTypeKHR = 1;
pub const VK_GEOMETRY_TYPE_AABBS_NV: VkGeometryTypeKHR = VK_GEOMETRY_TYPE_AABBS_KHR;
pub const VK_GEOMETRY_TYPE_INSTANCES_KHR: VkGeometryTypeKHR = 2;
pub const VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV: VkGeometryTypeKHR = 1000429005;
pub const VK_GEOMETRY_TYPE_SPHERES_NV: VkGeometryTypeKHR = 1000429004;
pub const VK_GEOMETRY_TYPE_TRIANGLES_KHR: VkGeometryTypeKHR = 0;
pub const VK_GEOMETRY_TYPE_TRIANGLES_NV: VkGeometryTypeKHR = VK_GEOMETRY_TYPE_TRIANGLES_KHR;
pub const VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME: &CStr = c"VK_GOOGLE_decorate_string";
pub const VK_GOOGLE_DECORATE_STRING_SPEC_VERSION: u32 = 1;
pub const VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME: &CStr = c"VK_GOOGLE_display_timing";
pub const VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION: u32 = 1;
pub const VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME: &CStr = VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME;
pub const VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION: u32 = VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION;
pub const VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME: &CStr = c"VK_GOOGLE_hlsl_functionality1";
pub const VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION: u32 = 1;
pub const VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME: &CStr = c"VK_GOOGLE_surfaceless_query";
pub const VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION: u32 = 2;
pub const VK_GOOGLE_USER_TYPE_EXTENSION_NAME: &CStr = c"VK_GOOGLE_user_type";
pub const VK_GOOGLE_USER_TYPE_SPEC_VERSION: u32 = 1;
pub const VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT: VkGraphicsPipelineLibraryFlagBitsEXT = 1 << 3;
pub const VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT: VkGraphicsPipelineLibraryFlagBitsEXT = 1 << 2;
pub const VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT: VkGraphicsPipelineLibraryFlagBitsEXT = 1 << 1;
pub const VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT: VkGraphicsPipelineLibraryFlagBitsEXT = 1 << 0;
pub const VK_HEADER_VERSION: u32 = 338;
pub const VK_HEADER_VERSION_COMPLETE: u32 = VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION);
pub const VK_HOST_IMAGE_COPY_MEMCPY: VkHostImageCopyFlagBits = VK_HOST_IMAGE_COPY_MEMCPY_BIT;
pub const VK_HOST_IMAGE_COPY_MEMCPY_BIT: VkHostImageCopyFlagBits = 1 << 0;
pub const VK_HOST_IMAGE_COPY_MEMCPY_BIT_EXT: VkHostImageCopyFlagBits = VK_HOST_IMAGE_COPY_MEMCPY_BIT;
pub const VK_HOST_IMAGE_COPY_MEMCPY_EXT: VkHostImageCopyFlagBits = VK_HOST_IMAGE_COPY_MEMCPY_BIT;
pub const VK_HUAWEI_CLUSTER_CULLING_SHADER_EXTENSION_NAME: &CStr = c"VK_HUAWEI_cluster_culling_shader";
pub const VK_HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION: u32 = 3;
pub const VK_HUAWEI_HDR_VIVID_EXTENSION_NAME: &CStr = c"VK_HUAWEI_hdr_vivid";
pub const VK_HUAWEI_HDR_VIVID_SPEC_VERSION: u32 = 1;
pub const VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME: &CStr = c"VK_HUAWEI_invocation_mask";
pub const VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION: u32 = 1;
pub const VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME: &CStr = c"VK_HUAWEI_subpass_shading";
pub const VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION: u32 = 3;
pub const VK_IMAGE_ASPECT_COLOR_BIT: VkImageAspectFlagBits = 1 << 0;
pub const VK_IMAGE_ASPECT_DEPTH_BIT: VkImageAspectFlagBits = 1 << 1;
pub const VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT: VkImageAspectFlagBits = 1 << 7;
pub const VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT: VkImageAspectFlagBits = 1 << 8;
pub const VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT: VkImageAspectFlagBits = 1 << 9;
pub const VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT: VkImageAspectFlagBits = 1 << 10;
pub const VK_IMAGE_ASPECT_METADATA_BIT: VkImageAspectFlagBits = 1 << 3;
pub const VK_IMAGE_ASPECT_NONE: VkImageAspectFlagBits = 0;
pub const VK_IMAGE_ASPECT_NONE_KHR: VkImageAspectFlagBits = VK_IMAGE_ASPECT_NONE;
pub const VK_IMAGE_ASPECT_PLANE_0_BIT: VkImageAspectFlagBits = 1 << 4;
pub const VK_IMAGE_ASPECT_PLANE_0_BIT_KHR: VkImageAspectFlagBits = VK_IMAGE_ASPECT_PLANE_0_BIT;
pub const VK_IMAGE_ASPECT_PLANE_1_BIT: VkImageAspectFlagBits = 1 << 5;
pub const VK_IMAGE_ASPECT_PLANE_1_BIT_KHR: VkImageAspectFlagBits = VK_IMAGE_ASPECT_PLANE_1_BIT;
pub const VK_IMAGE_ASPECT_PLANE_2_BIT: VkImageAspectFlagBits = 1 << 6;
pub const VK_IMAGE_ASPECT_PLANE_2_BIT_KHR: VkImageAspectFlagBits = VK_IMAGE_ASPECT_PLANE_2_BIT;
pub const VK_IMAGE_ASPECT_STENCIL_BIT: VkImageAspectFlagBits = 1 << 2;
pub const VK_IMAGE_COMPRESSION_DEFAULT_EXT: VkImageCompressionFlagBitsEXT = 0;
pub const VK_IMAGE_COMPRESSION_DISABLED_EXT: VkImageCompressionFlagBitsEXT = 1 << 2;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 9;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 10;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 11;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 12;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 13;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 14;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 15;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 16;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 17;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 18;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 0;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 19;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 20;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 21;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 22;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 23;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 1;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 2;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 3;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 4;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 5;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 6;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 7;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 8;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT: VkImageCompressionFlagBitsEXT = 1 << 0;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT: VkImageCompressionFlagBitsEXT = 1 << 1;
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT: VkImageCompressionFixedRateFlagBitsEXT = 0;
pub const VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT: VkImageCreateFlagBits = 1 << 5;
pub const VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT;
pub const VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT: VkImageCreateFlagBits = 1 << 17;
pub const VK_IMAGE_CREATE_ALIAS_BIT: VkImageCreateFlagBits = 1 << 10;
pub const VK_IMAGE_CREATE_ALIAS_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_ALIAS_BIT;
pub const VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT: VkImageCreateFlagBits = 1 << 7;
pub const VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT;
pub const VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV: VkImageCreateFlagBits = 1 << 13;
pub const VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT: VkImageCreateFlagBits = 1 << 4;
pub const VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkImageCreateFlagBits = 1 << 16;
pub const VK_IMAGE_CREATE_DISJOINT_BIT: VkImageCreateFlagBits = 1 << 9;
pub const VK_IMAGE_CREATE_DISJOINT_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_DISJOINT_BIT;
pub const VK_IMAGE_CREATE_EXTENDED_USAGE_BIT: VkImageCreateFlagBits = 1 << 8;
pub const VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT;
pub const VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT: VkImageCreateFlagBits = 1 << 15;
pub const VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM: VkImageCreateFlagBits = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT;
pub const VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT: VkImageCreateFlagBits = 1 << 18;
pub const VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT: VkImageCreateFlagBits = 1 << 3;
pub const VK_IMAGE_CREATE_PROTECTED_BIT: VkImageCreateFlagBits = 1 << 11;
pub const VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT: VkImageCreateFlagBits = 1 << 12;
pub const VK_IMAGE_CREATE_SPARSE_ALIASED_BIT: VkImageCreateFlagBits = 1 << 2;
pub const VK_IMAGE_CREATE_SPARSE_BINDING_BIT: VkImageCreateFlagBits = 1 << 0;
pub const VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT: VkImageCreateFlagBits = 1 << 1;
pub const VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT: VkImageCreateFlagBits = 1 << 6;
pub const VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT;
pub const VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT: VkImageCreateFlagBits = 1 << 14;
pub const VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR: VkImageCreateFlagBits = 1 << 20;
pub const VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT: VkImageLayout = 1000339000;
pub const VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL: VkImageLayout = 1000314001;
pub const VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL;
pub const VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: VkImageLayout = 2;
pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL: VkImageLayout = 1000241000;
pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: VkImageLayout = 1000117001;
pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL;
pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL: VkImageLayout = 1000241001;
pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL;
pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: VkImageLayout = 1000117000;
pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL;
pub const VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: VkImageLayout = 3;
pub const VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: VkImageLayout = 4;
pub const VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT: VkImageLayout = 1000218000;
pub const VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = 1000164003;
pub const VK_IMAGE_LAYOUT_GENERAL: VkImageLayout = 1;
pub const VK_IMAGE_LAYOUT_PREINITIALIZED: VkImageLayout = 8;
pub const VK_IMAGE_LAYOUT_PRESENT_SRC_KHR: VkImageLayout = 1000001002;
pub const VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL: VkImageLayout = 1000314000;
pub const VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL;
pub const VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ: VkImageLayout = 1000232000;
pub const VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR: VkImageLayout = VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ;
pub const VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: VkImageLayout = 5;
pub const VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV: VkImageLayout = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
pub const VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR: VkImageLayout = 1000111000;
pub const VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL: VkImageLayout = 1000241002;
pub const VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL;
pub const VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL: VkImageLayout = 1000241003;
pub const VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL;
pub const VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM: VkImageLayout = 1000460000;
pub const VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL: VkImageLayout = 7;
pub const VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: VkImageLayout = 6;
pub const VK_IMAGE_LAYOUT_UNDEFINED: VkImageLayout = 0;
pub const VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR: VkImageLayout = 1000024002;
pub const VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR: VkImageLayout = 1000024000;
pub const VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR: VkImageLayout = 1000024001;
pub const VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR: VkImageLayout = 1000299002;
pub const VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR: VkImageLayout = 1000299000;
pub const VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR: VkImageLayout = 1000553000;
pub const VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR: VkImageLayout = 1000299001;
pub const VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT: VkImageLayout = 1000620000;
pub const VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT: VkImageTiling = 1000158000;
pub const VK_IMAGE_TILING_LINEAR: VkImageTiling = 1;
pub const VK_IMAGE_TILING_OPTIMAL: VkImageTiling = 0;
pub const VK_IMAGE_TYPE_1D: VkImageType = 0;
pub const VK_IMAGE_TYPE_2D: VkImageType = 1;
pub const VK_IMAGE_TYPE_3D: VkImageType = 2;
pub const VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkImageUsageFlagBits = 1 << 19;
pub const VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT: VkImageUsageFlagBits = 1 << 4;
pub const VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT: VkImageUsageFlagBits = 1 << 5;
pub const VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT: VkImageUsageFlagBits = 1 << 9;
pub const VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkImageUsageFlagBits = 1 << 8;
pub const VK_IMAGE_USAGE_HOST_TRANSFER_BIT: VkImageUsageFlagBits = 1 << 22;
pub const VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT: VkImageUsageFlagBits = VK_IMAGE_USAGE_HOST_TRANSFER_BIT;
pub const VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT: VkImageUsageFlagBits = 1 << 7;
pub const VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI: VkImageUsageFlagBits = 1 << 18;
pub const VK_IMAGE_USAGE_SAMPLED_BIT: VkImageUsageFlagBits = 1 << 2;
pub const VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM: VkImageUsageFlagBits = 1 << 21;
pub const VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM: VkImageUsageFlagBits = 1 << 20;
pub const VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV: VkImageUsageFlagBits = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
pub const VK_IMAGE_USAGE_STORAGE_BIT: VkImageUsageFlagBits = 1 << 3;
pub const VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM: VkImageUsageFlagBits = 1 << 23;
pub const VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM: VkImageUsageFlagBits = 1 << 27;
pub const VK_IMAGE_USAGE_TRANSFER_DST_BIT: VkImageUsageFlagBits = 1 << 1;
pub const VK_IMAGE_USAGE_TRANSFER_SRC_BIT: VkImageUsageFlagBits = 1 << 0;
pub const VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT: VkImageUsageFlagBits = 1 << 6;
pub const VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR: VkImageUsageFlagBits = 1 << 12;
pub const VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR: VkImageUsageFlagBits = 1 << 10;
pub const VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR: VkImageUsageFlagBits = 1 << 11;
pub const VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR: VkImageUsageFlagBits = 1 << 15;
pub const VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR: VkImageUsageFlagBits = 1 << 13;
pub const VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR: VkImageUsageFlagBits = 1 << 26;
pub const VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: VkImageUsageFlagBits = 1 << 25;
pub const VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR: VkImageUsageFlagBits = 1 << 14;
pub const VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkImageViewCreateFlagBits = 1 << 2;
pub const VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT: VkImageViewCreateFlagBits = 1 << 1;
pub const VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT: VkImageViewCreateFlagBits = 1 << 0;
pub const VK_IMAGE_VIEW_TYPE_1D: VkImageViewType = 0;
pub const VK_IMAGE_VIEW_TYPE_1D_ARRAY: VkImageViewType = 4;
pub const VK_IMAGE_VIEW_TYPE_2D: VkImageViewType = 1;
pub const VK_IMAGE_VIEW_TYPE_2D_ARRAY: VkImageViewType = 5;
pub const VK_IMAGE_VIEW_TYPE_3D: VkImageViewType = 2;
pub const VK_IMAGE_VIEW_TYPE_CUBE: VkImageViewType = 3;
pub const VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: VkImageViewType = 6;
pub const VK_IMG_FILTER_CUBIC_EXTENSION_NAME: &CStr = c"VK_IMG_filter_cubic";
pub const VK_IMG_FILTER_CUBIC_SPEC_VERSION: u32 = 1;
pub const VK_IMG_FORMAT_PVRTC_EXTENSION_NAME: &CStr = c"VK_IMG_format_pvrtc";
pub const VK_IMG_FORMAT_PVRTC_SPEC_VERSION: u32 = 1;
pub const VK_IMG_RELAXED_LINE_RASTERIZATION_EXTENSION_NAME: &CStr = c"VK_IMG_relaxed_line_rasterization";
pub const VK_IMG_RELAXED_LINE_RASTERIZATION_SPEC_VERSION: u32 = 1;
pub const VK_INCOMPATIBLE_SHADER_BINARY_EXT: VkResult = 1000482000;
pub const VK_INCOMPLETE: VkResult = 5;
pub const VK_INDEX_TYPE_NONE_KHR: VkIndexType = 1000165000;
pub const VK_INDEX_TYPE_NONE_NV: VkIndexType = VK_INDEX_TYPE_NONE_KHR;
pub const VK_INDEX_TYPE_UINT16: VkIndexType = 0;
pub const VK_INDEX_TYPE_UINT32: VkIndexType = 1;
pub const VK_INDEX_TYPE_UINT8: VkIndexType = 1000265000;
pub const VK_INDEX_TYPE_UINT8_EXT: VkIndexType = VK_INDEX_TYPE_UINT8;
pub const VK_INDEX_TYPE_UINT8_KHR: VkIndexType = VK_INDEX_TYPE_UINT8;
pub const VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT: VkIndirectCommandsInputModeFlagBitsEXT = 1 << 1;
pub const VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT: VkIndirectCommandsInputModeFlagBitsEXT = 1 << 0;
pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT: VkIndirectCommandsLayoutUsageFlagBitsEXT = 1 << 0;
pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV: VkIndirectCommandsLayoutUsageFlagBitsNV = 1 << 0;
pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV: VkIndirectCommandsLayoutUsageFlagBitsNV = 1 << 1;
pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT: VkIndirectCommandsLayoutUsageFlagBitsEXT = 1 << 1;
pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV: VkIndirectCommandsLayoutUsageFlagBitsNV = 1 << 2;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT: VkIndirectCommandsTokenTypeEXT = 9;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV: VkIndirectCommandsTokenTypeNV = 1000428004;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT: VkIndirectCommandsTokenTypeEXT = 8;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT: VkIndirectCommandsTokenTypeEXT = 6;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT: VkIndirectCommandsTokenTypeEXT = 7;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT: VkIndirectCommandsTokenTypeEXT = 5;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV: VkIndirectCommandsTokenTypeNV = 5;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT: VkIndirectCommandsTokenTypeEXT = 1000328001;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT: VkIndirectCommandsTokenTypeEXT = 1000202003;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT: VkIndirectCommandsTokenTypeEXT = 1000328000;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV: VkIndirectCommandsTokenTypeNV = 1000328000;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT: VkIndirectCommandsTokenTypeEXT = 1000202002;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV: VkIndirectCommandsTokenTypeNV = 6;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV: VkIndirectCommandsTokenTypeNV = 7;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT: VkIndirectCommandsTokenTypeEXT = 0;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT: VkIndirectCommandsTokenTypeEXT = 3;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV: VkIndirectCommandsTokenTypeNV = 2;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV: VkIndirectCommandsTokenTypeNV = 1000428003;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT: VkIndirectCommandsTokenTypeEXT = 1;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV: VkIndirectCommandsTokenTypeNV = 4;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT: VkIndirectCommandsTokenTypeEXT = 2;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV: VkIndirectCommandsTokenTypeNV = 0;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV: VkIndirectCommandsTokenTypeNV = 1;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT: VkIndirectCommandsTokenTypeEXT = 1000386004;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT: VkIndirectCommandsTokenTypeEXT = 4;
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV: VkIndirectCommandsTokenTypeNV = 3;
pub const VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT: VkIndirectExecutionSetInfoTypeEXT = 0;
pub const VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT: VkIndirectExecutionSetInfoTypeEXT = 1;
pub const VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV: VkIndirectStateFlagBitsNV = 1 << 0;
pub const VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR: VkInstanceCreateFlagBits = 1 << 0;
pub const VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME: &CStr = c"VK_INTEL_performance_query";
pub const VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION: u32 = 2;
pub const VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME: &CStr = c"VK_INTEL_shader_integer_functions2";
pub const VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION: u32 = 1;
pub const VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE: VkInternalAllocationType = 0;
pub const VK_KHR_16BIT_STORAGE_EXTENSION_NAME: &CStr = c"VK_KHR_16bit_storage";
pub const VK_KHR_16BIT_STORAGE_SPEC_VERSION: u32 = 1;
pub const VK_KHR_8BIT_STORAGE_EXTENSION_NAME: &CStr = c"VK_KHR_8bit_storage";
pub const VK_KHR_8BIT_STORAGE_SPEC_VERSION: u32 = 1;
pub const VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME: &CStr = c"VK_KHR_acceleration_structure";
pub const VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION: u32 = 13;
pub const VK_KHR_BIND_MEMORY_2_EXTENSION_NAME: &CStr = c"VK_KHR_bind_memory2";
pub const VK_KHR_BIND_MEMORY_2_SPEC_VERSION: u32 = 1;
pub const VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME: &CStr = c"VK_KHR_buffer_device_address";
pub const VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION: u32 = 1;
pub const VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME: &CStr = c"VK_KHR_calibrated_timestamps";
pub const VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION: u32 = 1;
pub const VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME: &CStr = c"VK_KHR_compute_shader_derivatives";
pub const VK_KHR_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION: u32 = 1;
pub const VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME: &CStr = c"VK_KHR_cooperative_matrix";
pub const VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION: u32 = 2;
pub const VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME: &CStr = c"VK_KHR_copy_commands2";
pub const VK_KHR_COPY_COMMANDS_2_SPEC_VERSION: u32 = 1;
pub const VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME: &CStr = c"VK_KHR_copy_memory_indirect";
pub const VK_KHR_COPY_MEMORY_INDIRECT_SPEC_VERSION: u32 = 1;
pub const VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME: &CStr = c"VK_KHR_create_renderpass2";
pub const VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION: u32 = 1;
pub const VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME: &CStr = c"VK_KHR_dedicated_allocation";
pub const VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION: u32 = 3;
pub const VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME: &CStr = c"VK_KHR_deferred_host_operations";
pub const VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION: u32 = 4;
pub const VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME: &CStr = c"VK_KHR_depth_clamp_zero_one";
pub const VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION: u32 = 1;
pub const VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME: &CStr = c"VK_KHR_depth_stencil_resolve";
pub const VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION: u32 = 1;
pub const VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME: &CStr = c"VK_KHR_descriptor_update_template";
pub const VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION: u32 = 1;
pub const VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME: &CStr = c"VK_KHR_device_group_creation";
pub const VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION: u32 = 1;
pub const VK_KHR_DEVICE_GROUP_EXTENSION_NAME: &CStr = c"VK_KHR_device_group";
pub const VK_KHR_DEVICE_GROUP_SPEC_VERSION: u32 = 4;
pub const VK_KHR_DISPLAY_EXTENSION_NAME: &CStr = c"VK_KHR_display";
pub const VK_KHR_DISPLAY_SPEC_VERSION: u32 = 23;
pub const VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME: &CStr = c"VK_KHR_display_swapchain";
pub const VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION: u32 = 10;
pub const VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME: &CStr = c"VK_KHR_draw_indirect_count";
pub const VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION: u32 = 1;
pub const VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_KHR_driver_properties";
pub const VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION: u32 = 1;
pub const VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME: &CStr = c"VK_KHR_dynamic_rendering";
pub const VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME: &CStr = c"VK_KHR_dynamic_rendering_local_read";
pub const VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION: u32 = 1;
pub const VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION: u32 = 1;
pub const VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME: &CStr = c"VK_KHR_external_fence_capabilities";
pub const VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION: u32 = 1;
pub const VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME: &CStr = c"VK_KHR_external_fence";
pub const VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME: &CStr = c"VK_KHR_external_fence_fd";
pub const VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION: u32 = 1;
pub const VK_KHR_EXTERNAL_FENCE_SPEC_VERSION: u32 = 1;
pub const VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME: &CStr = c"VK_KHR_external_memory_capabilities";
pub const VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION: u32 = 1;
pub const VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME: &CStr = c"VK_KHR_external_memory";
pub const VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME: &CStr = c"VK_KHR_external_memory_fd";
pub const VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION: u32 = 1;
pub const VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION: u32 = 1;
pub const VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME: &CStr = c"VK_KHR_external_semaphore_capabilities";
pub const VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION: u32 = 1;
pub const VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME: &CStr = c"VK_KHR_external_semaphore";
pub const VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME: &CStr = c"VK_KHR_external_semaphore_fd";
pub const VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION: u32 = 1;
pub const VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION: u32 = 1;
pub const VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME: &CStr = c"VK_KHR_format_feature_flags2";
pub const VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION: u32 = 2;
pub const VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME: &CStr = c"VK_KHR_fragment_shader_barycentric";
pub const VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION: u32 = 1;
pub const VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME: &CStr = c"VK_KHR_fragment_shading_rate";
pub const VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION: u32 = 2;
pub const VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME: &CStr = c"VK_KHR_get_display_properties2";
pub const VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION: u32 = 1;
pub const VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME: &CStr = c"VK_KHR_get_memory_requirements2";
pub const VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION: u32 = 1;
pub const VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME: &CStr = c"VK_KHR_get_physical_device_properties2";
pub const VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION: u32 = 2;
pub const VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME: &CStr = c"VK_KHR_get_surface_capabilities2";
pub const VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION: u32 = 1;
pub const VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME: &CStr = c"VK_KHR_global_priority";
pub const VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION: u32 = 1;
pub const VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME: &CStr = c"VK_KHR_imageless_framebuffer";
pub const VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION: u32 = 1;
pub const VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME: &CStr = c"VK_KHR_image_format_list";
pub const VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION: u32 = 1;
pub const VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME: &CStr = c"VK_KHR_incremental_present";
pub const VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION: u32 = 2;
pub const VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME: &CStr = c"VK_KHR_index_type_uint8";
pub const VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION: u32 = 1;
pub const VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME: &CStr = c"VK_KHR_line_rasterization";
pub const VK_KHR_LINE_RASTERIZATION_SPEC_VERSION: u32 = 1;
pub const VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME: &CStr = c"VK_KHR_load_store_op_none";
pub const VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION: u32 = 1;
pub const VK_KHR_MAINTENANCE1_EXTENSION_NAME: &CStr = VK_KHR_MAINTENANCE_1_EXTENSION_NAME;
pub const VK_KHR_MAINTENANCE1_SPEC_VERSION: u32 = VK_KHR_MAINTENANCE_1_SPEC_VERSION;
pub const VK_KHR_MAINTENANCE2_EXTENSION_NAME: &CStr = VK_KHR_MAINTENANCE_2_EXTENSION_NAME;
pub const VK_KHR_MAINTENANCE2_SPEC_VERSION: u32 = VK_KHR_MAINTENANCE_2_SPEC_VERSION;
pub const VK_KHR_MAINTENANCE3_EXTENSION_NAME: &CStr = VK_KHR_MAINTENANCE_3_EXTENSION_NAME;
pub const VK_KHR_MAINTENANCE3_SPEC_VERSION: u32 = VK_KHR_MAINTENANCE_3_SPEC_VERSION;
pub const VK_KHR_MAINTENANCE_10_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance10";
pub const VK_KHR_MAINTENANCE_10_SPEC_VERSION: u32 = 1;
pub const VK_KHR_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance1";
pub const VK_KHR_MAINTENANCE_1_SPEC_VERSION: u32 = 2;
pub const VK_KHR_MAINTENANCE_2_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance2";
pub const VK_KHR_MAINTENANCE_2_SPEC_VERSION: u32 = 1;
pub const VK_KHR_MAINTENANCE_3_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance3";
pub const VK_KHR_MAINTENANCE_3_SPEC_VERSION: u32 = 1;
pub const VK_KHR_MAINTENANCE_4_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance4";
pub const VK_KHR_MAINTENANCE_4_SPEC_VERSION: u32 = 2;
pub const VK_KHR_MAINTENANCE_5_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance5";
pub const VK_KHR_MAINTENANCE_5_SPEC_VERSION: u32 = 1;
pub const VK_KHR_MAINTENANCE_6_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance6";
pub const VK_KHR_MAINTENANCE_6_SPEC_VERSION: u32 = 1;
pub const VK_KHR_MAINTENANCE_7_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance7";
pub const VK_KHR_MAINTENANCE_7_SPEC_VERSION: u32 = 1;
pub const VK_KHR_MAINTENANCE_8_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance8";
pub const VK_KHR_MAINTENANCE_8_SPEC_VERSION: u32 = 1;
pub const VK_KHR_MAINTENANCE_9_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance9";
pub const VK_KHR_MAINTENANCE_9_SPEC_VERSION: u32 = 1;
pub const VK_KHR_MAP_MEMORY_2_EXTENSION_NAME: &CStr = c"VK_KHR_map_memory2";
pub const VK_KHR_MAP_MEMORY_2_SPEC_VERSION: u32 = 1;
pub const VK_KHR_MULTIVIEW_EXTENSION_NAME: &CStr = c"VK_KHR_multiview";
pub const VK_KHR_MULTIVIEW_SPEC_VERSION: u32 = 1;
pub const VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME: &CStr = c"VK_KHR_performance_query";
pub const VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION: u32 = 1;
pub const VK_KHR_PIPELINE_BINARY_EXTENSION_NAME: &CStr = c"VK_KHR_pipeline_binary";
pub const VK_KHR_PIPELINE_BINARY_SPEC_VERSION: u32 = 1;
pub const VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_KHR_pipeline_executable_properties";
pub const VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION: u32 = 1;
pub const VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME: &CStr = c"VK_KHR_pipeline_library";
pub const VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION: u32 = 1;
pub const VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME: &CStr = c"VK_KHR_portability_enumeration";
pub const VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION: u32 = 1;
pub const VK_KHR_PRESENT_ID_2_EXTENSION_NAME: &CStr = c"VK_KHR_present_id2";
pub const VK_KHR_PRESENT_ID_2_SPEC_VERSION: u32 = 1;
pub const VK_KHR_PRESENT_ID_EXTENSION_NAME: &CStr = c"VK_KHR_present_id";
pub const VK_KHR_PRESENT_ID_SPEC_VERSION: u32 = 1;
pub const VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME: &CStr = c"VK_KHR_present_mode_fifo_latest_ready";
pub const VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION: u32 = 1;
pub const VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME: &CStr = c"VK_KHR_present_wait2";
pub const VK_KHR_PRESENT_WAIT_2_SPEC_VERSION: u32 = 1;
pub const VK_KHR_PRESENT_WAIT_EXTENSION_NAME: &CStr = c"VK_KHR_present_wait";
pub const VK_KHR_PRESENT_WAIT_SPEC_VERSION: u32 = 1;
pub const VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME: &CStr = c"VK_KHR_push_descriptor";
pub const VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION: u32 = 2;
pub const VK_KHR_RAY_QUERY_EXTENSION_NAME: &CStr = c"VK_KHR_ray_query";
pub const VK_KHR_RAY_QUERY_SPEC_VERSION: u32 = 1;
pub const VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_KHR_ray_tracing_maintenance1";
pub const VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
pub const VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME: &CStr = c"VK_KHR_ray_tracing_pipeline";
pub const VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION: u32 = 1;
pub const VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME: &CStr = c"VK_KHR_ray_tracing_position_fetch";
pub const VK_KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION: u32 = 1;
pub const VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME: &CStr = c"VK_KHR_relaxed_block_layout";
pub const VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION: u32 = 1;
pub const VK_KHR_ROBUSTNESS_2_EXTENSION_NAME: &CStr = c"VK_KHR_robustness2";
pub const VK_KHR_ROBUSTNESS_2_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME: &CStr = c"VK_KHR_sampler_mirror_clamp_to_edge";
pub const VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION: u32 = 3;
pub const VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME: &CStr = c"VK_KHR_sampler_ycbcr_conversion";
pub const VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION: u32 = 14;
pub const VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME: &CStr = c"VK_KHR_separate_depth_stencil_layouts";
pub const VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME: &CStr = c"VK_KHR_shader_atomic_int64";
pub const VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME: &CStr = c"VK_KHR_shader_bfloat16";
pub const VK_KHR_SHADER_BFLOAT16_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_CLOCK_EXTENSION_NAME: &CStr = c"VK_KHR_shader_clock";
pub const VK_KHR_SHADER_CLOCK_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME: &CStr = c"VK_KHR_shader_draw_parameters";
pub const VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME: &CStr = c"VK_KHR_shader_expect_assume";
pub const VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME: &CStr = c"VK_KHR_shader_float16_int8";
pub const VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME: &CStr = c"VK_KHR_shader_float_controls2";
pub const VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME: &CStr = c"VK_KHR_shader_float_controls";
pub const VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION: u32 = 4;
pub const VK_KHR_SHADER_FMA_EXTENSION_NAME: &CStr = c"VK_KHR_shader_fma";
pub const VK_KHR_SHADER_FMA_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME: &CStr = c"VK_KHR_shader_integer_dot_product";
pub const VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME: &CStr = c"VK_KHR_shader_maximal_reconvergence";
pub const VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME: &CStr = c"VK_KHR_shader_non_semantic_info";
pub const VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME: &CStr = c"VK_KHR_shader_quad_control";
pub const VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME: &CStr = c"VK_KHR_shader_relaxed_extended_instruction";
pub const VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME: &CStr = c"VK_KHR_shader_subgroup_extended_types";
pub const VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME: &CStr = c"VK_KHR_shader_subgroup_rotate";
pub const VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION: u32 = 2;
pub const VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME: &CStr = c"VK_KHR_shader_subgroup_uniform_control_flow";
pub const VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME: &CStr = c"VK_KHR_shader_terminate_invocation";
pub const VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME: &CStr = c"VK_KHR_shader_untyped_pointers";
pub const VK_KHR_SHADER_UNTYPED_POINTERS_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME: &CStr = c"VK_KHR_shared_presentable_image";
pub const VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SPIRV_1_4_EXTENSION_NAME: &CStr = c"VK_KHR_spirv_1_4";
pub const VK_KHR_SPIRV_1_4_SPEC_VERSION: u32 = 1;
pub const VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME: &CStr = c"VK_KHR_storage_buffer_storage_class";
pub const VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SURFACE_EXTENSION_NAME: &CStr = c"VK_KHR_surface";
pub const VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_KHR_surface_maintenance1";
pub const VK_KHR_SURFACE_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME: &CStr = c"VK_KHR_surface_protected_capabilities";
pub const VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SURFACE_SPEC_VERSION: u32 = 25;
pub const VK_KHR_SWAPCHAIN_EXTENSION_NAME: &CStr = c"VK_KHR_swapchain";
pub const VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_KHR_swapchain_maintenance1";
pub const VK_KHR_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME: &CStr = c"VK_KHR_swapchain_mutable_format";
pub const VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION: u32 = 1;
pub const VK_KHR_SWAPCHAIN_SPEC_VERSION: u32 = 70;
pub const VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME: &CStr = c"VK_KHR_synchronization2";
pub const VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION: u32 = 1;
pub const VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME: &CStr = c"VK_KHR_timeline_semaphore";
pub const VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION: u32 = 2;
pub const VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME: &CStr = c"VK_KHR_unified_image_layouts";
pub const VK_KHR_UNIFIED_IMAGE_LAYOUTS_SPEC_VERSION: u32 = 1;
pub const VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME: &CStr = c"VK_KHR_uniform_buffer_standard_layout";
pub const VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION: u32 = 1;
pub const VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME: &CStr = c"VK_KHR_variable_pointers";
pub const VK_KHR_VARIABLE_POINTERS_SPEC_VERSION: u32 = 1;
pub const VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME: &CStr = c"VK_KHR_vertex_attribute_divisor";
pub const VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION: u32 = 1;
pub const VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME: &CStr = c"VK_KHR_video_decode_av1";
pub const VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION: u32 = 1;
pub const VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME: &CStr = c"VK_KHR_video_decode_h264";
pub const VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION: u32 = 9;
pub const VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME: &CStr = c"VK_KHR_video_decode_h265";
pub const VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION: u32 = 8;
pub const VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME: &CStr = c"VK_KHR_video_decode_queue";
pub const VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION: u32 = 8;
pub const VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME: &CStr = c"VK_KHR_video_decode_vp9";
pub const VK_KHR_VIDEO_DECODE_VP9_SPEC_VERSION: u32 = 1;
pub const VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_av1";
pub const VK_KHR_VIDEO_ENCODE_AV1_SPEC_VERSION: u32 = 1;
pub const VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_h264";
pub const VK_KHR_VIDEO_ENCODE_H264_SPEC_VERSION: u32 = 14;
pub const VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_h265";
pub const VK_KHR_VIDEO_ENCODE_H265_SPEC_VERSION: u32 = 14;
pub const VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_intra_refresh";
pub const VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_SPEC_VERSION: u32 = 1;
pub const VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_quantization_map";
pub const VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_SPEC_VERSION: u32 = 2;
pub const VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_queue";
pub const VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION: u32 = 12;
pub const VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_KHR_video_maintenance1";
pub const VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
pub const VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME: &CStr = c"VK_KHR_video_maintenance2";
pub const VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION: u32 = 1;
pub const VK_KHR_VIDEO_QUEUE_EXTENSION_NAME: &CStr = c"VK_KHR_video_queue";
pub const VK_KHR_VIDEO_QUEUE_SPEC_VERSION: u32 = 8;
pub const VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME: &CStr = c"VK_KHR_vulkan_memory_model";
pub const VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION: u32 = 3;
pub const VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME: &CStr = c"VK_KHR_workgroup_memory_explicit_layout";
pub const VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION: u32 = 1;
pub const VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME: &CStr = c"VK_KHR_zero_initialize_workgroup_memory";
pub const VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION: u32 = 1;
pub const VK_LATENCY_MARKER_INPUT_SAMPLE_NV: VkLatencyMarkerNV = 6;
pub const VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV: VkLatencyMarkerNV = 11;
pub const VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV: VkLatencyMarkerNV = 10;
pub const VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV: VkLatencyMarkerNV = 9;
pub const VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV: VkLatencyMarkerNV = 8;
pub const VK_LATENCY_MARKER_PRESENT_END_NV: VkLatencyMarkerNV = 5;
pub const VK_LATENCY_MARKER_PRESENT_START_NV: VkLatencyMarkerNV = 4;
pub const VK_LATENCY_MARKER_RENDERSUBMIT_END_NV: VkLatencyMarkerNV = 3;
pub const VK_LATENCY_MARKER_RENDERSUBMIT_START_NV: VkLatencyMarkerNV = 2;
pub const VK_LATENCY_MARKER_SIMULATION_END_NV: VkLatencyMarkerNV = 1;
pub const VK_LATENCY_MARKER_SIMULATION_START_NV: VkLatencyMarkerNV = 0;
pub const VK_LATENCY_MARKER_TRIGGER_FLASH_NV: VkLatencyMarkerNV = 7;
pub const VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT: VkLayeredDriverUnderlyingApiMSFT = 1;
pub const VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT: VkLayeredDriverUnderlyingApiMSFT = 0;
pub const VK_LAYER_SETTING_TYPE_BOOL32_EXT: VkLayerSettingTypeEXT = 0;
pub const VK_LAYER_SETTING_TYPE_FLOAT32_EXT: VkLayerSettingTypeEXT = 5;
pub const VK_LAYER_SETTING_TYPE_FLOAT64_EXT: VkLayerSettingTypeEXT = 6;
pub const VK_LAYER_SETTING_TYPE_INT32_EXT: VkLayerSettingTypeEXT = 1;
pub const VK_LAYER_SETTING_TYPE_INT64_EXT: VkLayerSettingTypeEXT = 2;
pub const VK_LAYER_SETTING_TYPE_STRING_EXT: VkLayerSettingTypeEXT = 7;
pub const VK_LAYER_SETTING_TYPE_UINT32_EXT: VkLayerSettingTypeEXT = 3;
pub const VK_LAYER_SETTING_TYPE_UINT64_EXT: VkLayerSettingTypeEXT = 4;
pub const VK_LINE_RASTERIZATION_MODE_BRESENHAM: VkLineRasterizationMode = 2;
pub const VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_BRESENHAM;
pub const VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_BRESENHAM;
pub const VK_LINE_RASTERIZATION_MODE_DEFAULT: VkLineRasterizationMode = 0;
pub const VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_DEFAULT;
pub const VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_DEFAULT;
pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR: VkLineRasterizationMode = 1;
pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR;
pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR;
pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH: VkLineRasterizationMode = 3;
pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH;
pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH;
pub const VK_LOD_CLAMP_NONE: f32 = 1000.0;
pub const VK_LOGIC_OP_AND: VkLogicOp = 1;
pub const VK_LOGIC_OP_AND_INVERTED: VkLogicOp = 4;
pub const VK_LOGIC_OP_AND_REVERSE: VkLogicOp = 2;
pub const VK_LOGIC_OP_CLEAR: VkLogicOp = 0;
pub const VK_LOGIC_OP_COPY: VkLogicOp = 3;
pub const VK_LOGIC_OP_COPY_INVERTED: VkLogicOp = 12;
pub const VK_LOGIC_OP_EQUIVALENT: VkLogicOp = 9;
pub const VK_LOGIC_OP_INVERT: VkLogicOp = 10;
pub const VK_LOGIC_OP_NAND: VkLogicOp = 14;
pub const VK_LOGIC_OP_NOR: VkLogicOp = 8;
pub const VK_LOGIC_OP_NO_OP: VkLogicOp = 5;
pub const VK_LOGIC_OP_OR: VkLogicOp = 7;
pub const VK_LOGIC_OP_OR_INVERTED: VkLogicOp = 13;
pub const VK_LOGIC_OP_OR_REVERSE: VkLogicOp = 11;
pub const VK_LOGIC_OP_SET: VkLogicOp = 15;
pub const VK_LOGIC_OP_XOR: VkLogicOp = 6;
pub const VK_LUID_SIZE: u32 = 8;
pub const VK_LUID_SIZE_KHR: u32 = VK_LUID_SIZE;
pub const VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME: &CStr = c"VK_LUNARG_direct_driver_loading";
pub const VK_LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION: u32 = 1;
pub const VK_MAX_DESCRIPTION_SIZE: u32 = 256;
pub const VK_MAX_DEVICE_GROUP_SIZE: u32 = 32;
pub const VK_MAX_DEVICE_GROUP_SIZE_KHR: u32 = VK_MAX_DEVICE_GROUP_SIZE;
pub const VK_MAX_DRIVER_INFO_SIZE: u32 = 256;
pub const VK_MAX_DRIVER_INFO_SIZE_KHR: u32 = VK_MAX_DRIVER_INFO_SIZE;
pub const VK_MAX_DRIVER_NAME_SIZE: u32 = 256;
pub const VK_MAX_DRIVER_NAME_SIZE_KHR: u32 = VK_MAX_DRIVER_NAME_SIZE;
pub const VK_MAX_EXTENSION_NAME_SIZE: u32 = 256;
pub const VK_MAX_GLOBAL_PRIORITY_SIZE: u32 = 16;
pub const VK_MAX_GLOBAL_PRIORITY_SIZE_EXT: u32 = VK_MAX_GLOBAL_PRIORITY_SIZE;
pub const VK_MAX_GLOBAL_PRIORITY_SIZE_KHR: u32 = VK_MAX_GLOBAL_PRIORITY_SIZE;
pub const VK_MAX_MEMORY_HEAPS: u32 = 16;
pub const VK_MAX_MEMORY_TYPES: u32 = 32;
pub const VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM: u32 = 128;
pub const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE: u32 = 256;
pub const VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR: u32 = 32;
pub const VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT: u32 = 32;
pub const VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR: u32 = 7;
pub const VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR: u32 = 3;
pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT: VkMemoryAllocateFlagBits = 1 << 1;
pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR: VkMemoryAllocateFlagBits = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT;
pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT: VkMemoryAllocateFlagBits = 1 << 2;
pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: VkMemoryAllocateFlagBits = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
pub const VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT: VkMemoryAllocateFlagBits = 1 << 0;
pub const VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR: VkMemoryAllocateFlagBits = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT;
pub const VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT: VkMemoryAllocateFlagBits = 1 << 3;
pub const VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT: VkMemoryDecompressionMethodFlagBitsEXT = 1 << 0;
pub const VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV: VkMemoryDecompressionMethodFlagBitsEXT = VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT;
pub const VK_MEMORY_HEAP_DEVICE_LOCAL_BIT: VkMemoryHeapFlagBits = 1 << 0;
pub const VK_MEMORY_HEAP_MULTI_INSTANCE_BIT: VkMemoryHeapFlagBits = 1 << 1;
pub const VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR: VkMemoryHeapFlagBits = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT;
pub const VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM: VkMemoryHeapFlagBits = 1 << 3;
pub const VK_MEMORY_MAP_PLACED_BIT_EXT: VkMemoryMapFlagBits = 1 << 0;
pub const VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD: VkMemoryOverallocationBehaviorAMD = 1;
pub const VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD: VkMemoryOverallocationBehaviorAMD = 0;
pub const VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD: VkMemoryOverallocationBehaviorAMD = 2;
pub const VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD: VkMemoryPropertyFlagBits = 1 << 6;
pub const VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT: VkMemoryPropertyFlagBits = 1 << 0;
pub const VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD: VkMemoryPropertyFlagBits = 1 << 7;
pub const VK_MEMORY_PROPERTY_HOST_CACHED_BIT: VkMemoryPropertyFlagBits = 1 << 3;
pub const VK_MEMORY_PROPERTY_HOST_COHERENT_BIT: VkMemoryPropertyFlagBits = 1 << 2;
pub const VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT: VkMemoryPropertyFlagBits = 1 << 1;
pub const VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT: VkMemoryPropertyFlagBits = 1 << 4;
pub const VK_MEMORY_PROPERTY_PROTECTED_BIT: VkMemoryPropertyFlagBits = 1 << 5;
pub const VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV: VkMemoryPropertyFlagBits = 1 << 8;
pub const VK_MEMORY_UNMAP_RESERVE_BIT_EXT: VkMemoryUnmapFlagBits = 1 << 0;
pub const VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME: &CStr = c"VK_MESA_image_alignment_control";
pub const VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION: u32 = 1;
pub const VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT: VkMicromapCreateFlagBitsEXT = 1 << 0;
pub const VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT: VkMicromapTypeEXT = 0;
pub const VK_MSFT_LAYERED_DRIVER_EXTENSION_NAME: &CStr = c"VK_MSFT_layered_driver";
pub const VK_MSFT_LAYERED_DRIVER_SPEC_VERSION: u32 = 1;
pub const VK_NOT_READY: VkResult = 1;
pub const VK_NVX_BINARY_IMPORT_EXTENSION_NAME: &CStr = c"VK_NVX_binary_import";
pub const VK_NVX_BINARY_IMPORT_SPEC_VERSION: u32 = 2;
pub const VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME: &CStr = c"VK_NVX_image_view_handle";
pub const VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION: u32 = 3;
pub const VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME: &CStr = c"VK_NVX_multiview_per_view_attributes";
pub const VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION: u32 = 1;
pub const VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME: &CStr = c"VK_NV_clip_space_w_scaling";
pub const VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION: u32 = 1;
pub const VK_NV_CLUSTER_ACCELERATION_STRUCTURE_EXTENSION_NAME: &CStr = c"VK_NV_cluster_acceleration_structure";
pub const VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION: u32 = 4;
pub const VK_NV_COMMAND_BUFFER_INHERITANCE_EXTENSION_NAME: &CStr = c"VK_NV_command_buffer_inheritance";
pub const VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION: u32 = 1;
pub const VK_NV_COMPUTE_OCCUPANCY_PRIORITY_EXTENSION_NAME: &CStr = c"VK_NV_compute_occupancy_priority";
pub const VK_NV_COMPUTE_OCCUPANCY_PRIORITY_SPEC_VERSION: u32 = 1;
pub const VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME: &CStr = c"VK_NV_compute_shader_derivatives";
pub const VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION: u32 = 1;
pub const VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME: &CStr = c"VK_NV_cooperative_matrix2";
pub const VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION: u32 = 1;
pub const VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME: &CStr = c"VK_NV_cooperative_matrix";
pub const VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION: u32 = 1;
pub const VK_NV_COOPERATIVE_VECTOR_EXTENSION_NAME: &CStr = c"VK_NV_cooperative_vector";
pub const VK_NV_COOPERATIVE_VECTOR_SPEC_VERSION: u32 = 4;
pub const VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME: &CStr = c"VK_NV_copy_memory_indirect";
pub const VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION: u32 = 1;
pub const VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME: &CStr = c"VK_NV_corner_sampled_image";
pub const VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION: u32 = 2;
pub const VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME: &CStr = c"VK_NV_coverage_reduction_mode";
pub const VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION: u32 = 1;
pub const VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME: &CStr = c"VK_NV_dedicated_allocation";
pub const VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME: &CStr = c"VK_NV_dedicated_allocation_image_aliasing";
pub const VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION: u32 = 1;
pub const VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION: u32 = 1;
pub const VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME: &CStr = c"VK_NV_descriptor_pool_overallocation";
pub const VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION: u32 = 1;
pub const VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME: &CStr = c"VK_NV_device_diagnostics_config";
pub const VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION: u32 = 2;
pub const VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME: &CStr = c"VK_NV_device_diagnostic_checkpoints";
pub const VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION: u32 = 2;
pub const VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_EXTENSION_NAME: &CStr = c"VK_NV_device_generated_commands_compute";
pub const VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_SPEC_VERSION: u32 = 2;
pub const VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME: &CStr = c"VK_NV_device_generated_commands";
pub const VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION: u32 = 3;
pub const VK_NV_DISPLAY_STEREO_EXTENSION_NAME: &CStr = c"VK_NV_display_stereo";
pub const VK_NV_DISPLAY_STEREO_SPEC_VERSION: u32 = 1;
pub const VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_EXTENSION_NAME: &CStr = c"VK_NV_extended_sparse_address_space";
pub const VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION: u32 = 1;
pub const VK_NV_EXTERNAL_COMPUTE_QUEUE_EXTENSION_NAME: &CStr = c"VK_NV_external_compute_queue";
pub const VK_NV_EXTERNAL_COMPUTE_QUEUE_SPEC_VERSION: u32 = 1;
pub const VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME: &CStr = c"VK_NV_external_memory_capabilities";
pub const VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION: u32 = 1;
pub const VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME: &CStr = c"VK_NV_external_memory";
pub const VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME: &CStr = c"VK_NV_external_memory_rdma";
pub const VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION: u32 = 1;
pub const VK_NV_EXTERNAL_MEMORY_SPEC_VERSION: u32 = 1;
pub const VK_NV_FILL_RECTANGLE_EXTENSION_NAME: &CStr = c"VK_NV_fill_rectangle";
pub const VK_NV_FILL_RECTANGLE_SPEC_VERSION: u32 = 1;
pub const VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME: &CStr = c"VK_NV_fragment_coverage_to_color";
pub const VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION: u32 = 1;
pub const VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME: &CStr = c"VK_NV_fragment_shader_barycentric";
pub const VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION: u32 = 1;
pub const VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME: &CStr = c"VK_NV_fragment_shading_rate_enums";
pub const VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION: u32 = 1;
pub const VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME: &CStr = c"VK_NV_framebuffer_mixed_samples";
pub const VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION: u32 = 1;
pub const VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME: &CStr = c"VK_NV_geometry_shader_passthrough";
pub const VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION: u32 = 1;
pub const VK_NV_GLSL_SHADER_EXTENSION_NAME: &CStr = c"VK_NV_glsl_shader";
pub const VK_NV_GLSL_SHADER_SPEC_VERSION: u32 = 1;
pub const VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME: &CStr = c"VK_NV_inherited_viewport_scissor";
pub const VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION: u32 = 1;
pub const VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME: &CStr = c"VK_NV_linear_color_attachment";
pub const VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION: u32 = 1;
pub const VK_NV_LOW_LATENCY_2_EXTENSION_NAME: &CStr = c"VK_NV_low_latency2";
pub const VK_NV_LOW_LATENCY_2_SPEC_VERSION: u32 = 2;
pub const VK_NV_LOW_LATENCY_EXTENSION_NAME: &CStr = c"VK_NV_low_latency";
pub const VK_NV_LOW_LATENCY_SPEC_VERSION: u32 = 1;
pub const VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME: &CStr = c"VK_NV_memory_decompression";
pub const VK_NV_MEMORY_DECOMPRESSION_SPEC_VERSION: u32 = 1;
pub const VK_NV_MESH_SHADER_EXTENSION_NAME: &CStr = c"VK_NV_mesh_shader";
pub const VK_NV_MESH_SHADER_SPEC_VERSION: u32 = 1;
pub const VK_NV_OPTICAL_FLOW_EXTENSION_NAME: &CStr = c"VK_NV_optical_flow";
pub const VK_NV_OPTICAL_FLOW_SPEC_VERSION: u32 = 1;
pub const VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_EXTENSION_NAME: &CStr = c"VK_NV_partitioned_acceleration_structure";
pub const VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_SPEC_VERSION: u32 = 1;
pub const VK_NV_PER_STAGE_DESCRIPTOR_SET_EXTENSION_NAME: &CStr = c"VK_NV_per_stage_descriptor_set";
pub const VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION: u32 = 1;
pub const VK_NV_PRESENT_BARRIER_EXTENSION_NAME: &CStr = c"VK_NV_present_barrier";
pub const VK_NV_PRESENT_BARRIER_SPEC_VERSION: u32 = 1;
pub const VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME: &CStr = c"VK_NV_raw_access_chains";
pub const VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION: u32 = 1;
pub const VK_NV_RAY_TRACING_EXTENSION_NAME: &CStr = c"VK_NV_ray_tracing";
pub const VK_NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME: &CStr = c"VK_NV_ray_tracing_invocation_reorder";
pub const VK_NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION: u32 = 1;
pub const VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_EXTENSION_NAME: &CStr = c"VK_NV_ray_tracing_linear_swept_spheres";
pub const VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_SPEC_VERSION: u32 = 1;
pub const VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME: &CStr = c"VK_NV_ray_tracing_motion_blur";
pub const VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION: u32 = 1;
pub const VK_NV_RAY_TRACING_SPEC_VERSION: u32 = 3;
pub const VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME: &CStr = c"VK_NV_ray_tracing_validation";
pub const VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION: u32 = 1;
pub const VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME: &CStr = c"VK_NV_representative_fragment_test";
pub const VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION: u32 = 2;
pub const VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME: &CStr = c"VK_NV_sample_mask_override_coverage";
pub const VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION: u32 = 1;
pub const VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME: &CStr = c"VK_NV_scissor_exclusive";
pub const VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION: u32 = 2;
pub const VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME: &CStr = c"VK_NV_shader_atomic_float16_vector";
pub const VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION: u32 = 1;
pub const VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME: &CStr = c"VK_NV_shader_image_footprint";
pub const VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION: u32 = 2;
pub const VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME: &CStr = c"VK_NV_shader_sm_builtins";
pub const VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION: u32 = 1;
pub const VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME: &CStr = c"VK_NV_shader_subgroup_partitioned";
pub const VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION: u32 = 1;
pub const VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME: &CStr = c"VK_NV_shading_rate_image";
pub const VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION: u32 = 3;
pub const VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME: &CStr = VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME;
pub const VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION: u32 = VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION;
pub const VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME: &CStr = c"VK_NV_viewport_array2";
pub const VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION: u32 = 1;
pub const VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME: &CStr = c"VK_NV_viewport_swizzle";
pub const VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION: u32 = 1;
pub const VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR: VkObjectType = 1000150000;
pub const VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV: VkObjectType = 1000165000;
pub const VK_OBJECT_TYPE_BUFFER: VkObjectType = 9;
pub const VK_OBJECT_TYPE_BUFFER_VIEW: VkObjectType = 13;
pub const VK_OBJECT_TYPE_COMMAND_BUFFER: VkObjectType = 6;
pub const VK_OBJECT_TYPE_COMMAND_POOL: VkObjectType = 25;
pub const VK_OBJECT_TYPE_CU_FUNCTION_NVX: VkObjectType = 1000029001;
pub const VK_OBJECT_TYPE_CU_MODULE_NVX: VkObjectType = 1000029000;
pub const VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM: VkObjectType = 1000507000;
pub const VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT: VkObjectType = 1000011000;
pub const VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT: VkObjectType = 1000128000;
pub const VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR: VkObjectType = 1000268000;
pub const VK_OBJECT_TYPE_DESCRIPTOR_POOL: VkObjectType = 22;
pub const VK_OBJECT_TYPE_DESCRIPTOR_SET: VkObjectType = 23;
pub const VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT: VkObjectType = 20;
pub const VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE: VkObjectType = 1000085000;
pub const VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR: VkObjectType = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE;
pub const VK_OBJECT_TYPE_DEVICE: VkObjectType = 3;
pub const VK_OBJECT_TYPE_DEVICE_MEMORY: VkObjectType = 8;
pub const VK_OBJECT_TYPE_DISPLAY_KHR: VkObjectType = 1000002000;
pub const VK_OBJECT_TYPE_DISPLAY_MODE_KHR: VkObjectType = 1000002001;
pub const VK_OBJECT_TYPE_EVENT: VkObjectType = 11;
pub const VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV: VkObjectType = 1000556000;
pub const VK_OBJECT_TYPE_FENCE: VkObjectType = 7;
pub const VK_OBJECT_TYPE_FRAMEBUFFER: VkObjectType = 24;
pub const VK_OBJECT_TYPE_IMAGE: VkObjectType = 10;
pub const VK_OBJECT_TYPE_IMAGE_VIEW: VkObjectType = 14;
pub const VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT: VkObjectType = 1000572000;
pub const VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV: VkObjectType = 1000277000;
pub const VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT: VkObjectType = 1000572001;
pub const VK_OBJECT_TYPE_INSTANCE: VkObjectType = 1;
pub const VK_OBJECT_TYPE_MICROMAP_EXT: VkObjectType = 1000396000;
pub const VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV: VkObjectType = 1000464000;
pub const VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL: VkObjectType = 1000210000;
pub const VK_OBJECT_TYPE_PHYSICAL_DEVICE: VkObjectType = 2;
pub const VK_OBJECT_TYPE_PIPELINE: VkObjectType = 19;
pub const VK_OBJECT_TYPE_PIPELINE_BINARY_KHR: VkObjectType = 1000483000;
pub const VK_OBJECT_TYPE_PIPELINE_CACHE: VkObjectType = 16;
pub const VK_OBJECT_TYPE_PIPELINE_LAYOUT: VkObjectType = 17;
pub const VK_OBJECT_TYPE_PRIVATE_DATA_SLOT: VkObjectType = 1000295000;
pub const VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT: VkObjectType = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT;
pub const VK_OBJECT_TYPE_QUERY_POOL: VkObjectType = 12;
pub const VK_OBJECT_TYPE_QUEUE: VkObjectType = 4;
pub const VK_OBJECT_TYPE_RENDER_PASS: VkObjectType = 18;
pub const VK_OBJECT_TYPE_SAMPLER: VkObjectType = 21;
pub const VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION: VkObjectType = 1000156000;
pub const VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR: VkObjectType = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION;
pub const VK_OBJECT_TYPE_SEMAPHORE: VkObjectType = 5;
pub const VK_OBJECT_TYPE_SHADER_EXT: VkObjectType = 1000482000;
pub const VK_OBJECT_TYPE_SHADER_MODULE: VkObjectType = 15;
pub const VK_OBJECT_TYPE_SURFACE_KHR: VkObjectType = 1000000000;
pub const VK_OBJECT_TYPE_SWAPCHAIN_KHR: VkObjectType = 1000001000;
pub const VK_OBJECT_TYPE_TENSOR_ARM: VkObjectType = 1000460000;
pub const VK_OBJECT_TYPE_TENSOR_VIEW_ARM: VkObjectType = 1000460001;
pub const VK_OBJECT_TYPE_UNKNOWN: VkObjectType = 0;
pub const VK_OBJECT_TYPE_VALIDATION_CACHE_EXT: VkObjectType = 1000160000;
pub const VK_OBJECT_TYPE_VIDEO_SESSION_KHR: VkObjectType = 1000023000;
pub const VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR: VkObjectType = 1000023001;
pub const VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT: VkOpacityMicromapFormatEXT = 1;
pub const VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT: VkOpacityMicromapFormatEXT = 2;
pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV: VkOpacityMicromapSpecialIndexEXT = -5;
pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT: VkOpacityMicromapSpecialIndexEXT = -2;
pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT: VkOpacityMicromapSpecialIndexEXT = -1;
pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT: VkOpacityMicromapSpecialIndexEXT = -4;
pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT: VkOpacityMicromapSpecialIndexEXT = -3;
pub const VK_OPERATION_DEFERRED_KHR: VkResult = 1000268002;
pub const VK_OPERATION_NOT_DEFERRED_KHR: VkResult = 1000268003;
pub const VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV: VkOpticalFlowExecuteFlagBitsNV = 1 << 0;
pub const VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV: VkOpticalFlowGridSizeFlagBitsNV = 1 << 0;
pub const VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV: VkOpticalFlowGridSizeFlagBitsNV = 1 << 1;
pub const VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV: VkOpticalFlowGridSizeFlagBitsNV = 1 << 2;
pub const VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV: VkOpticalFlowGridSizeFlagBitsNV = 1 << 3;
pub const VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV: VkOpticalFlowGridSizeFlagBitsNV = 0;
pub const VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV: VkOpticalFlowPerformanceLevelNV = 3;
pub const VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV: VkOpticalFlowPerformanceLevelNV = 2;
pub const VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV: VkOpticalFlowPerformanceLevelNV = 1;
pub const VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV: VkOpticalFlowPerformanceLevelNV = 0;
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV: VkOpticalFlowSessionBindingPointNV = 7;
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV: VkOpticalFlowSessionBindingPointNV = 5;
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV: VkOpticalFlowSessionBindingPointNV = 6;
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV: VkOpticalFlowSessionBindingPointNV = 4;
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV: VkOpticalFlowSessionBindingPointNV = 8;
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV: VkOpticalFlowSessionBindingPointNV = 3;
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV: VkOpticalFlowSessionBindingPointNV = 1;
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV: VkOpticalFlowSessionBindingPointNV = 2;
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV: VkOpticalFlowSessionBindingPointNV = 0;
pub const VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV: VkOpticalFlowSessionCreateFlagBitsNV = 1 << 3;
pub const VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV: VkOpticalFlowSessionCreateFlagBitsNV = 1 << 4;
pub const VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV: VkOpticalFlowSessionCreateFlagBitsNV = 1 << 1;
pub const VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV: VkOpticalFlowSessionCreateFlagBitsNV = 1 << 2;
pub const VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV: VkOpticalFlowSessionCreateFlagBitsNV = 1 << 0;
pub const VK_OPTICAL_FLOW_USAGE_COST_BIT_NV: VkOpticalFlowUsageFlagBitsNV = 1 << 3;
pub const VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV: VkOpticalFlowUsageFlagBitsNV = 1 << 4;
pub const VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV: VkOpticalFlowUsageFlagBitsNV = 1 << 2;
pub const VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV: VkOpticalFlowUsageFlagBitsNV = 1 << 0;
pub const VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV: VkOpticalFlowUsageFlagBitsNV = 1 << 1;
pub const VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV: VkOpticalFlowUsageFlagBitsNV = 0;
pub const VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV: VkOutOfBandQueueTypeNV = 1;
pub const VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV: VkOutOfBandQueueTypeNV = 0;
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV: VkPartitionedAccelerationStructureInstanceFlagBitsNV = 1 << 4;
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV: VkPartitionedAccelerationStructureInstanceFlagBitsNV = 1 << 3;
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV: VkPartitionedAccelerationStructureInstanceFlagBitsNV = 1 << 2;
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV: VkPartitionedAccelerationStructureInstanceFlagBitsNV = 1 << 0;
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV: VkPartitionedAccelerationStructureInstanceFlagBitsNV = 1 << 1;
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV: VkPartitionedAccelerationStructureOpTypeNV = 1;
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV: VkPartitionedAccelerationStructureOpTypeNV = 0;
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV: VkPartitionedAccelerationStructureOpTypeNV = 2;
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV: u32 = !0;
pub const VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT: VkPastPresentationTimingFlagBitsEXT = 1 << 1;
pub const VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT: VkPastPresentationTimingFlagBitsEXT = 1 << 0;
pub const VK_PEER_MEMORY_FEATURE_COPY_DST_BIT: VkPeerMemoryFeatureFlagBits = 1 << 1;
pub const VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR: VkPeerMemoryFeatureFlagBits = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT;
pub const VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT: VkPeerMemoryFeatureFlagBits = 1 << 0;
pub const VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR: VkPeerMemoryFeatureFlagBits = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT;
pub const VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT: VkPeerMemoryFeatureFlagBits = 1 << 3;
pub const VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR: VkPeerMemoryFeatureFlagBits = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT;
pub const VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT: VkPeerMemoryFeatureFlagBits = 1 << 2;
pub const VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR: VkPeerMemoryFeatureFlagBits = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT;
pub const VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL: VkPerformanceConfigurationTypeINTEL = 0;
pub const VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR: VkPerformanceCounterDescriptionFlagBitsKHR = 1 << 1;
pub const VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR: VkPerformanceCounterDescriptionFlagBitsKHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR;
pub const VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR: VkPerformanceCounterDescriptionFlagBitsKHR = 1 << 0;
pub const VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR: VkPerformanceCounterDescriptionFlagBitsKHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR;
pub const VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR: VkPerformanceCounterScopeKHR = 0;
pub const VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR: VkPerformanceCounterScopeKHR = 2;
pub const VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR: VkPerformanceCounterScopeKHR = 1;
pub const VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR: VkPerformanceCounterStorageKHR = 4;
pub const VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR: VkPerformanceCounterStorageKHR = 5;
pub const VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR: VkPerformanceCounterStorageKHR = 0;
pub const VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR: VkPerformanceCounterStorageKHR = 1;
pub const VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR: VkPerformanceCounterStorageKHR = 2;
pub const VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR: VkPerformanceCounterStorageKHR = 3;
pub const VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR: VkPerformanceCounterUnitKHR = 8;
pub const VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR: VkPerformanceCounterUnitKHR = 3;
pub const VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR: VkPerformanceCounterUnitKHR = 4;
pub const VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR: VkPerformanceCounterUnitKHR = 10;
pub const VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR: VkPerformanceCounterUnitKHR = 0;
pub const VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR: VkPerformanceCounterUnitKHR = 9;
pub const VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR: VkPerformanceCounterUnitKHR = 5;
pub const VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR: VkPerformanceCounterUnitKHR = 2;
pub const VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR: VkPerformanceCounterUnitKHR = 1;
pub const VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR: VkPerformanceCounterUnitKHR = 7;
pub const VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR: VkPerformanceCounterUnitKHR = 6;
pub const VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL: VkPerformanceOverrideTypeINTEL = 1;
pub const VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL: VkPerformanceOverrideTypeINTEL = 0;
pub const VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL: VkPerformanceParameterTypeINTEL = 0;
pub const VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL: VkPerformanceParameterTypeINTEL = 1;
pub const VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL: VkPerformanceValueTypeINTEL = 3;
pub const VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL: VkPerformanceValueTypeINTEL = 2;
pub const VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL: VkPerformanceValueTypeINTEL = 4;
pub const VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL: VkPerformanceValueTypeINTEL = 0;
pub const VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL: VkPerformanceValueTypeINTEL = 1;
pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM: VkPhysicalDeviceDataGraphOperationTypeARM = 1000629001;
pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM: VkPhysicalDeviceDataGraphOperationTypeARM = 1000629000;
pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM: VkPhysicalDeviceDataGraphOperationTypeARM = 0;
pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM: VkPhysicalDeviceDataGraphProcessingEngineTypeARM = 1000629001;
pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM: VkPhysicalDeviceDataGraphProcessingEngineTypeARM = 0;
pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM: VkPhysicalDeviceDataGraphProcessingEngineTypeARM = 1000629000;
pub const VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR: VkPhysicalDeviceLayeredApiKHR = 1;
pub const VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR: VkPhysicalDeviceLayeredApiKHR = 2;
pub const VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR: VkPhysicalDeviceLayeredApiKHR = 4;
pub const VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR: VkPhysicalDeviceLayeredApiKHR = 3;
pub const VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR: VkPhysicalDeviceLayeredApiKHR = 0;
pub const VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM: VkPhysicalDeviceSchedulingControlsFlagBitsARM = 1 << 0;
pub const VK_PHYSICAL_DEVICE_TYPE_CPU: VkPhysicalDeviceType = 4;
pub const VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: VkPhysicalDeviceType = 2;
pub const VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: VkPhysicalDeviceType = 1;
pub const VK_PHYSICAL_DEVICE_TYPE_OTHER: VkPhysicalDeviceType = 0;
pub const VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU: VkPhysicalDeviceType = 3;
pub const VK_PIPELINE_BINARY_MISSING_KHR: VkResult = 1000483000;
pub const VK_PIPELINE_BIND_POINT_COMPUTE: VkPipelineBindPoint = 1;
pub const VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM: VkPipelineBindPoint = 1000507000;
pub const VK_PIPELINE_BIND_POINT_GRAPHICS: VkPipelineBindPoint = 0;
pub const VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR: VkPipelineBindPoint = 1000165000;
pub const VK_PIPELINE_BIND_POINT_RAY_TRACING_NV: VkPipelineBindPoint = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR;
pub const VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI: VkPipelineBindPoint = 1000369003;
pub const VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT: VkPipelineCacheCreateFlagBits = 1 << 0;
pub const VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT: VkPipelineCacheCreateFlagBits = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT;
pub const VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR: VkPipelineCacheCreateFlagBits = 1 << 3;
pub const VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM: VkPipelineCacheHeaderVersion = 1000629000;
pub const VK_PIPELINE_CACHE_HEADER_VERSION_ONE: VkPipelineCacheHeaderVersion = 1;
pub const VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM: VkPipelineColorBlendStateCreateFlagBits = 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_EXT: VkPipelineColorBlendStateCreateFlagBits = 1 << 0;
pub const VK_PIPELINE_COMPILE_REQUIRED: VkResult = 1000297000;
pub const VK_PIPELINE_COMPILE_REQUIRED_EXT: VkResult = VK_PIPELINE_COMPILE_REQUIRED;
pub const VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 43;
pub const VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT: VkPipelineCreateFlagBits2 = 1 << 1;
pub const VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT;
pub const VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 31;
pub const VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 7;
pub const VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 6;
pub const VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 25;
pub const VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV: VkPipelineCreateFlagBits2 = 1 << 5;
pub const VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 26;
pub const VK_PIPELINE_CREATE_2_DERIVATIVE_BIT: VkPipelineCreateFlagBits2 = 1 << 2;
pub const VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_DERIVATIVE_BIT;
pub const VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 29;
pub const VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT: VkPipelineCreateFlagBits2 = 1 << 0;
pub const VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT;
pub const VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM: VkPipelineCreateFlagBits2 = 1 << 37;
pub const VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT: VkPipelineCreateFlagBits2 = 1 << 4;
pub const VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT;
pub const VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT: VkPipelineCreateFlagBits2 = 1 << 9;
pub const VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT;
pub const VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 34;
pub const VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT: VkPipelineCreateFlagBits2 = 1 << 8;
pub const VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT;
pub const VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 38;
pub const VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV: VkPipelineCreateFlagBits2 = 1 << 18;
pub const VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 11;
pub const VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 10;
pub const VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT: VkPipelineCreateFlagBits2 = 1 << 27;
pub const VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT;
pub const VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE: VkPipelineCreateFlagBits2 = 1 << 40;
pub const VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT: VkPipelineCreateFlagBits2 = 1 << 30;
pub const VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT;
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV: VkPipelineCreateFlagBits2 = 1 << 20;
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV: VkPipelineCreateFlagBits2 = 1 << 33;
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV: VkPipelineCreateFlagBits2 = 1 << 28;
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 14;
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 15;
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 17;
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 16;
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 24;
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 19;
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 13;
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR;
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 12;
pub const VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 22;
pub const VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 21;
pub const VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 23;
pub const VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT: VkPipelineCreateFlagBits2 = 1 << 3;
pub const VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT;
pub const VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT: VkPipelineCreateFlagBits = 1 << 1;
pub const VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 7;
pub const VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 6;
pub const VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkPipelineCreateFlagBits = 1 << 25;
pub const VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV: VkPipelineCreateFlagBits = 1 << 5;
pub const VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkPipelineCreateFlagBits = 1 << 26;
pub const VK_PIPELINE_CREATE_DERIVATIVE_BIT: VkPipelineCreateFlagBits = 1 << 2;
pub const VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT: VkPipelineCreateFlagBits = 1 << 29;
pub const VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: VkPipelineCreateFlagBits = 1 << 0;
pub const VK_PIPELINE_CREATE_DISPATCH_BASE: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT;
pub const VK_PIPELINE_CREATE_DISPATCH_BASE_BIT: VkPipelineCreateFlagBits = 1 << 4;
pub const VK_PIPELINE_CREATE_DISPATCH_BASE_BIT_KHR: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT;
pub const VK_PIPELINE_CREATE_DISPATCH_BASE_KHR: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT;
pub const VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT: VkPipelineCreateFlagBits = 1 << 9;
pub const VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT;
pub const VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT: VkPipelineCreateFlagBits = 1 << 8;
pub const VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT;
pub const VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV: VkPipelineCreateFlagBits = 1 << 18;
pub const VK_PIPELINE_CREATE_LIBRARY_BIT_KHR: VkPipelineCreateFlagBits = 1 << 11;
pub const VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT: VkPipelineCreateFlagBits = 1 << 10;
pub const VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT: VkPipelineCreateFlagBits = 1 << 27;
pub const VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT;
pub const VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT: VkPipelineCreateFlagBits = 1 << 30;
pub const VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT;
pub const VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV: VkPipelineCreateFlagBits = 1 << 20;
pub const VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 14;
pub const VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 15;
pub const VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 17;
pub const VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 16;
pub const VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT: VkPipelineCreateFlagBits = 1 << 24;
pub const VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR: VkPipelineCreateFlagBits = 1 << 19;
pub const VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 13;
pub const VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR: VkPipelineCreateFlagBits = 1 << 12;
pub const VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: VkPipelineCreateFlagBits = 1 << 22;
pub const VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineCreateFlagBits = 1 << 21;
pub const VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT: VkPipelineCreateFlagBits = 1 << 23;
pub const VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT: VkPipelineCreateFlagBits = 1 << 3;
pub const VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT;
pub const VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT: VkPipelineCreationFeedbackFlagBits = 1 << 1;
pub const VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT: VkPipelineCreationFeedbackFlagBits = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT;
pub const VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT: VkPipelineCreationFeedbackFlagBits = 1 << 2;
pub const VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT: VkPipelineCreationFeedbackFlagBits = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT;
pub const VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT: VkPipelineCreationFeedbackFlagBits = 1 << 0;
pub const VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT: VkPipelineCreationFeedbackFlagBits = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT;
pub const VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM: VkPipelineDepthStencilStateCreateFlagBits = 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_EXT: VkPipelineDepthStencilStateCreateFlagBits = 1 << 0;
pub const VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM: VkPipelineDepthStencilStateCreateFlagBits = 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_EXT: VkPipelineDepthStencilStateCreateFlagBits = 1 << 1;
pub const VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR: VkPipelineExecutableStatisticFormatKHR = 0;
pub const VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR: VkPipelineExecutableStatisticFormatKHR = 3;
pub const VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR: VkPipelineExecutableStatisticFormatKHR = 1;
pub const VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR: VkPipelineExecutableStatisticFormatKHR = 2;
pub const VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT: VkPipelineLayoutCreateFlagBits = 1 << 1;
pub const VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT;
pub const VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT: VkPipelineRobustnessBufferBehavior = 0;
pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT: VkPipelineRobustnessBufferBehavior = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT;
pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED: VkPipelineRobustnessBufferBehavior = 1;
pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT: VkPipelineRobustnessBufferBehavior = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED;
pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS: VkPipelineRobustnessBufferBehavior = 2;
pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2: VkPipelineRobustnessBufferBehavior = 3;
pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT: VkPipelineRobustnessBufferBehavior = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2;
pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT: VkPipelineRobustnessBufferBehavior = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS;
pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT: VkPipelineRobustnessImageBehavior = 0;
pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT: VkPipelineRobustnessImageBehavior = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT;
pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED: VkPipelineRobustnessImageBehavior = 1;
pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT: VkPipelineRobustnessImageBehavior = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED;
pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS: VkPipelineRobustnessImageBehavior = 2;
pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2: VkPipelineRobustnessImageBehavior = 3;
pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT: VkPipelineRobustnessImageBehavior = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2;
pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT: VkPipelineRobustnessImageBehavior = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS;
pub const VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT: VkPipelineShaderStageCreateFlagBits = 1 << 0;
pub const VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT: VkPipelineShaderStageCreateFlagBits = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT;
pub const VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT: VkPipelineShaderStageCreateFlagBits = 1 << 1;
pub const VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT: VkPipelineShaderStageCreateFlagBits = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT;
pub const VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 25;
pub const VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
pub const VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 28;
pub const VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT: VkPipelineStageFlagBits2 = 1 << 16;
pub const VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT;
pub const VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT: VkPipelineStageFlagBits2 = 1 << 15;
pub const VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT;
pub const VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT: VkPipelineStageFlagBits2 = 1 << 12;
pub const VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT;
pub const VK_PIPELINE_STAGE_2_BLIT_BIT: VkPipelineStageFlagBits2 = 1 << 34;
pub const VK_PIPELINE_STAGE_2_BLIT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_BLIT_BIT;
pub const VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT: VkPipelineStageFlagBits2 = 1 << 13;
pub const VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT;
pub const VK_PIPELINE_STAGE_2_CLEAR_BIT: VkPipelineStageFlagBits2 = 1 << 35;
pub const VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_CLEAR_BIT;
pub const VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI: VkPipelineStageFlagBits2 = 1 << 41;
pub const VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT: VkPipelineStageFlagBits2 = 1 << 10;
pub const VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
pub const VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 17;
pub const VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT;
pub const VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 11;
pub const VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
pub const VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 18;
pub const VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV: VkPipelineStageFlagBits2 = 1 << 44;
pub const VK_PIPELINE_STAGE_2_COPY_BIT: VkPipelineStageFlagBits2 = 1 << 32;
pub const VK_PIPELINE_STAGE_2_COPY_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_COPY_BIT;
pub const VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 46;
pub const VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM: VkPipelineStageFlagBits2 = 1 << 42;
pub const VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT: VkPipelineStageFlagBits2 = 1 << 1;
pub const VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT;
pub const VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT: VkPipelineStageFlagBits2 = 1 << 8;
pub const VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT;
pub const VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 23;
pub const VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 7;
pub const VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT;
pub const VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 22;
pub const VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 6;
pub const VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT;
pub const VK_PIPELINE_STAGE_2_HOST_BIT: VkPipelineStageFlagBits2 = 1 << 14;
pub const VK_PIPELINE_STAGE_2_HOST_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_HOST_BIT;
pub const VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT: VkPipelineStageFlagBits2 = 1 << 36;
pub const VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT;
pub const VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI: VkPipelineStageFlagBits2 = 1 << 40;
pub const VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT: VkPipelineStageFlagBits2 = 1 << 9;
pub const VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT;
pub const VK_PIPELINE_STAGE_2_MEMORY_DECOMPRESSION_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 45;
pub const VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 20;
pub const VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT;
pub const VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 30;
pub const VK_PIPELINE_STAGE_2_NONE: VkPipelineStageFlagBits2 = 0;
pub const VK_PIPELINE_STAGE_2_NONE_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_NONE;
pub const VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV: VkPipelineStageFlagBits2 = 1 << 29;
pub const VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT: VkPipelineStageFlagBits2 = 1 << 38;
pub const VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT;
pub const VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 21;
pub const VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR;
pub const VK_PIPELINE_STAGE_2_RESOLVE_BIT: VkPipelineStageFlagBits2 = 1 << 33;
pub const VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_RESOLVE_BIT;
pub const VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
pub const VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI: VkPipelineStageFlagBits2 = 1 << 39;
pub const VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI;
pub const VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 19;
pub const VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT;
pub const VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 4;
pub const VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT;
pub const VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 5;
pub const VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT;
pub const VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT: VkPipelineStageFlagBits2 = 1 << 0;
pub const VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT;
pub const VK_PIPELINE_STAGE_2_TRANSFER_BIT: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT;
pub const VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT;
pub const VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 24;
pub const VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT: VkPipelineStageFlagBits2 = 1 << 37;
pub const VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT;
pub const VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT: VkPipelineStageFlagBits2 = 1 << 2;
pub const VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT;
pub const VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 3;
pub const VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT;
pub const VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 26;
pub const VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 27;
pub const VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR: VkPipelineStageFlagBits = 1 << 25;
pub const VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
pub const VK_PIPELINE_STAGE_ALL_COMMANDS_BIT: VkPipelineStageFlagBits = 1 << 16;
pub const VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT: VkPipelineStageFlagBits = 1 << 15;
pub const VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT: VkPipelineStageFlagBits = 1 << 13;
pub const VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT: VkPipelineStageFlagBits = 1 << 10;
pub const VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT: VkPipelineStageFlagBits = 1 << 17;
pub const VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT;
pub const VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT: VkPipelineStageFlagBits = 1 << 11;
pub const VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT: VkPipelineStageFlagBits = 1 << 18;
pub const VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT: VkPipelineStageFlagBits = 1 << 1;
pub const VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT: VkPipelineStageFlagBits = 1 << 8;
pub const VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT: VkPipelineStageFlagBits = 1 << 23;
pub const VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT: VkPipelineStageFlagBits = 1 << 7;
pub const VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineStageFlagBits = 1 << 22;
pub const VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT: VkPipelineStageFlagBits = 1 << 6;
pub const VK_PIPELINE_STAGE_HOST_BIT: VkPipelineStageFlagBits = 1 << 14;
pub const VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT: VkPipelineStageFlagBits = 1 << 9;
pub const VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT: VkPipelineStageFlagBits = 1 << 20;
pub const VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT;
pub const VK_PIPELINE_STAGE_NONE: VkPipelineStageFlagBits = 0;
pub const VK_PIPELINE_STAGE_NONE_KHR: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_NONE;
pub const VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR: VkPipelineStageFlagBits = 1 << 21;
pub const VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
pub const VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
pub const VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT: VkPipelineStageFlagBits = 1 << 19;
pub const VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT;
pub const VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT: VkPipelineStageFlagBits = 1 << 4;
pub const VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT: VkPipelineStageFlagBits = 1 << 5;
pub const VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT: VkPipelineStageFlagBits = 1 << 0;
pub const VK_PIPELINE_STAGE_TRANSFER_BIT: VkPipelineStageFlagBits = 1 << 12;
pub const VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT: VkPipelineStageFlagBits = 1 << 24;
pub const VK_PIPELINE_STAGE_VERTEX_INPUT_BIT: VkPipelineStageFlagBits = 1 << 2;
pub const VK_PIPELINE_STAGE_VERTEX_SHADER_BIT: VkPipelineStageFlagBits = 1 << 3;
pub const VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES: VkPointClippingBehavior = 0;
pub const VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR: VkPointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES;
pub const VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY: VkPointClippingBehavior = 1;
pub const VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR: VkPointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY;
pub const VK_POLYGON_MODE_FILL: VkPolygonMode = 0;
pub const VK_POLYGON_MODE_FILL_RECTANGLE_NV: VkPolygonMode = 1000153000;
pub const VK_POLYGON_MODE_LINE: VkPolygonMode = 1;
pub const VK_POLYGON_MODE_POINT: VkPolygonMode = 2;
pub const VK_PRESENT_GRAVITY_CENTERED_BIT_EXT: VkPresentGravityFlagBitsKHR = VK_PRESENT_GRAVITY_CENTERED_BIT_KHR;
pub const VK_PRESENT_GRAVITY_CENTERED_BIT_KHR: VkPresentGravityFlagBitsKHR = 1 << 2;
pub const VK_PRESENT_GRAVITY_MAX_BIT_EXT: VkPresentGravityFlagBitsKHR = VK_PRESENT_GRAVITY_MAX_BIT_KHR;
pub const VK_PRESENT_GRAVITY_MAX_BIT_KHR: VkPresentGravityFlagBitsKHR = 1 << 1;
pub const VK_PRESENT_GRAVITY_MIN_BIT_EXT: VkPresentGravityFlagBitsKHR = VK_PRESENT_GRAVITY_MIN_BIT_KHR;
pub const VK_PRESENT_GRAVITY_MIN_BIT_KHR: VkPresentGravityFlagBitsKHR = 1 << 0;
pub const VK_PRESENT_MODE_FIFO_KHR: VkPresentModeKHR = 2;
pub const VK_PRESENT_MODE_FIFO_LATEST_READY_EXT: VkPresentModeKHR = VK_PRESENT_MODE_FIFO_LATEST_READY_KHR;
pub const VK_PRESENT_MODE_FIFO_LATEST_READY_KHR: VkPresentModeKHR = 1000361000;
pub const VK_PRESENT_MODE_FIFO_RELAXED_KHR: VkPresentModeKHR = 3;
pub const VK_PRESENT_MODE_IMMEDIATE_KHR: VkPresentModeKHR = 0;
pub const VK_PRESENT_MODE_MAILBOX_KHR: VkPresentModeKHR = 1;
pub const VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR: VkPresentModeKHR = 1000111001;
pub const VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR: VkPresentModeKHR = 1000111000;
pub const VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT: VkPresentScalingFlagBitsKHR = VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR;
pub const VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR: VkPresentScalingFlagBitsKHR = 1 << 1;
pub const VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT: VkPresentScalingFlagBitsKHR = VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR;
pub const VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR: VkPresentScalingFlagBitsKHR = 1 << 0;
pub const VK_PRESENT_SCALING_STRETCH_BIT_EXT: VkPresentScalingFlagBitsKHR = VK_PRESENT_SCALING_STRETCH_BIT_KHR;
pub const VK_PRESENT_SCALING_STRETCH_BIT_KHR: VkPresentScalingFlagBitsKHR = 1 << 2;
pub const VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT: VkPresentStageFlagBitsEXT = 1 << 2;
pub const VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT: VkPresentStageFlagBitsEXT = 1 << 3;
pub const VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT: VkPresentStageFlagBitsEXT = 1 << 0;
pub const VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT: VkPresentStageFlagBitsEXT = 1 << 1;
pub const VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT: VkPresentTimingInfoFlagBitsEXT = 1 << 1;
pub const VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT: VkPresentTimingInfoFlagBitsEXT = 1 << 0;
pub const VK_PRIMITIVE_TOPOLOGY_LINE_LIST: VkPrimitiveTopology = 1;
pub const VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY: VkPrimitiveTopology = 6;
pub const VK_PRIMITIVE_TOPOLOGY_LINE_STRIP: VkPrimitiveTopology = 2;
pub const VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY: VkPrimitiveTopology = 7;
pub const VK_PRIMITIVE_TOPOLOGY_PATCH_LIST: VkPrimitiveTopology = 10;
pub const VK_PRIMITIVE_TOPOLOGY_POINT_LIST: VkPrimitiveTopology = 0;
pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN: VkPrimitiveTopology = 5;
pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST: VkPrimitiveTopology = 3;
pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY: VkPrimitiveTopology = 8;
pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP: VkPrimitiveTopology = 4;
pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY: VkPrimitiveTopology = 9;
pub const VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT: VkProvokingVertexModeEXT = 0;
pub const VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT: VkProvokingVertexModeEXT = 1;
pub const VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME: &CStr = c"VK_QCOM_data_graph_model";
pub const VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION: u32 = 1;
pub const VK_QCOM_FILTER_CUBIC_CLAMP_EXTENSION_NAME: &CStr = c"VK_QCOM_filter_cubic_clamp";
pub const VK_QCOM_FILTER_CUBIC_CLAMP_SPEC_VERSION: u32 = 1;
pub const VK_QCOM_FILTER_CUBIC_WEIGHTS_EXTENSION_NAME: &CStr = c"VK_QCOM_filter_cubic_weights";
pub const VK_QCOM_FILTER_CUBIC_WEIGHTS_SPEC_VERSION: u32 = 1;
pub const VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME: &CStr = c"VK_QCOM_fragment_density_map_offset";
pub const VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION: u32 = 3;
pub const VK_QCOM_IMAGE_PROCESSING_2_EXTENSION_NAME: &CStr = c"VK_QCOM_image_processing2";
pub const VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION: u32 = 1;
pub const VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME: &CStr = c"VK_QCOM_image_processing";
pub const VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION: u32 = 1;
pub const VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME: &CStr = c"VK_QCOM_multiview_per_view_render_areas";
pub const VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION: u32 = 1;
pub const VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_EXTENSION_NAME: &CStr = c"VK_QCOM_multiview_per_view_viewports";
pub const VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION: u32 = 1;
pub const VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME: &CStr = c"VK_QCOM_render_pass_shader_resolve";
pub const VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION: u32 = 4;
pub const VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME: &CStr = c"VK_QCOM_render_pass_store_ops";
pub const VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION: u32 = 2;
pub const VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME: &CStr = c"VK_QCOM_render_pass_transform";
pub const VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION: u32 = 5;
pub const VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME: &CStr = c"VK_QCOM_rotated_copy_commands";
pub const VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION: u32 = 2;
pub const VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME: &CStr = c"VK_QCOM_tile_memory_heap";
pub const VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION: u32 = 1;
pub const VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_QCOM_tile_properties";
pub const VK_QCOM_TILE_PROPERTIES_SPEC_VERSION: u32 = 1;
pub const VK_QCOM_TILE_SHADING_EXTENSION_NAME: &CStr = c"VK_QCOM_tile_shading";
pub const VK_QCOM_TILE_SHADING_SPEC_VERSION: u32 = 2;
pub const VK_QCOM_YCBCR_DEGAMMA_EXTENSION_NAME: &CStr = c"VK_QCOM_ycbcr_degamma";
pub const VK_QCOM_YCBCR_DEGAMMA_SPEC_VERSION: u32 = 1;
pub const VK_QUERY_CONTROL_PRECISE_BIT: VkQueryControlFlagBits = 1 << 0;
pub const VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 5;
pub const VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT: VkQueryPipelineStatisticFlagBits = 1 << 6;
pub const VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI: VkQueryPipelineStatisticFlagBits = 1 << 13;
pub const VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 10;
pub const VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 7;
pub const VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 3;
pub const VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT: VkQueryPipelineStatisticFlagBits = 1 << 4;
pub const VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT: VkQueryPipelineStatisticFlagBits = 1 << 1;
pub const VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT: VkQueryPipelineStatisticFlagBits = 1 << 0;
pub const VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT: VkQueryPipelineStatisticFlagBits = 1 << 12;
pub const VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT: VkQueryPipelineStatisticFlagBits = 1 << 11;
pub const VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT: VkQueryPipelineStatisticFlagBits = 1 << 8;
pub const VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 9;
pub const VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 2;
pub const VK_QUERY_POOL_CREATE_RESET_BIT_KHR: VkQueryPoolCreateFlagBits = 1 << 0;
pub const VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL: VkQueryPoolSamplingModeINTEL = 0;
pub const VK_QUERY_RESULT_64_BIT: VkQueryResultFlagBits = 1 << 0;
pub const VK_QUERY_RESULT_PARTIAL_BIT: VkQueryResultFlagBits = 1 << 3;
pub const VK_QUERY_RESULT_STATUS_COMPLETE_KHR: VkQueryResultStatusKHR = 1;
pub const VK_QUERY_RESULT_STATUS_ERROR_KHR: VkQueryResultStatusKHR = -1;
pub const VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR: VkQueryResultStatusKHR = -1000299000;
pub const VK_QUERY_RESULT_STATUS_NOT_READY_KHR: VkQueryResultStatusKHR = 0;
pub const VK_QUERY_RESULT_WAIT_BIT: VkQueryResultFlagBits = 1 << 1;
pub const VK_QUERY_RESULT_WITH_AVAILABILITY_BIT: VkQueryResultFlagBits = 1 << 2;
pub const VK_QUERY_RESULT_WITH_STATUS_BIT_KHR: VkQueryResultFlagBits = 1 << 4;
pub const VK_QUERY_SCOPE_COMMAND_BUFFER_KHR: VkPerformanceCounterScopeKHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR;
pub const VK_QUERY_SCOPE_COMMAND_KHR: VkPerformanceCounterScopeKHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR;
pub const VK_QUERY_SCOPE_RENDER_PASS_KHR: VkPerformanceCounterScopeKHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR;
pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR: VkQueryType = 1000150000;
pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV: VkQueryType = 1000165000;
pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR: VkQueryType = 1000386000;
pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR: VkQueryType = 1000150001;
pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR: VkQueryType = 1000386001;
pub const VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT: VkQueryType = 1000328000;
pub const VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT: VkQueryType = 1000396001;
pub const VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT: VkQueryType = 1000396000;
pub const VK_QUERY_TYPE_OCCLUSION: VkQueryType = 0;
pub const VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL: VkQueryType = 1000210000;
pub const VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR: VkQueryType = 1000116000;
pub const VK_QUERY_TYPE_PIPELINE_STATISTICS: VkQueryType = 1;
pub const VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT: VkQueryType = 1000382000;
pub const VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR: VkQueryType = 1000023000;
pub const VK_QUERY_TYPE_TIMESTAMP: VkQueryType = 2;
pub const VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT: VkQueryType = 1000028004;
pub const VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR: VkQueryType = 1000299000;
pub const VK_QUEUE_COMPUTE_BIT: VkQueueFlagBits = 1 << 1;
pub const VK_QUEUE_DATA_GRAPH_BIT_ARM: VkQueueFlagBits = 1 << 10;
pub const VK_QUEUE_FAMILY_EXTERNAL: u32 = !1;
pub const VK_QUEUE_FAMILY_EXTERNAL_KHR: u32 = VK_QUEUE_FAMILY_EXTERNAL;
pub const VK_QUEUE_FAMILY_FOREIGN_EXT: u32 = !2;
pub const VK_QUEUE_FAMILY_IGNORED: u32 = !0;
pub const VK_QUEUE_GLOBAL_PRIORITY_HIGH: VkQueueGlobalPriority = 512;
pub const VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_HIGH;
pub const VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_HIGH;
pub const VK_QUEUE_GLOBAL_PRIORITY_LOW: VkQueueGlobalPriority = 128;
pub const VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_LOW;
pub const VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_LOW;
pub const VK_QUEUE_GLOBAL_PRIORITY_MEDIUM: VkQueueGlobalPriority = 256;
pub const VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM;
pub const VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM;
pub const VK_QUEUE_GLOBAL_PRIORITY_REALTIME: VkQueueGlobalPriority = 1024;
pub const VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_REALTIME;
pub const VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_REALTIME;
pub const VK_QUEUE_GRAPHICS_BIT: VkQueueFlagBits = 1 << 0;
pub const VK_QUEUE_OPTICAL_FLOW_BIT_NV: VkQueueFlagBits = 1 << 8;
pub const VK_QUEUE_PROTECTED_BIT: VkQueueFlagBits = 1 << 4;
pub const VK_QUEUE_SPARSE_BINDING_BIT: VkQueueFlagBits = 1 << 3;
pub const VK_QUEUE_TRANSFER_BIT: VkQueueFlagBits = 1 << 2;
pub const VK_QUEUE_VIDEO_DECODE_BIT_KHR: VkQueueFlagBits = 1 << 5;
pub const VK_QUEUE_VIDEO_ENCODE_BIT_KHR: VkQueueFlagBits = 1 << 6;
pub const VK_RASTERIZATION_ORDER_RELAXED_AMD: VkRasterizationOrderAMD = 1;
pub const VK_RASTERIZATION_ORDER_STRICT_AMD: VkRasterizationOrderAMD = 0;
pub const VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT: VkRayTracingInvocationReorderModeEXT = 0;
pub const VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV: VkRayTracingInvocationReorderModeEXT = VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT;
pub const VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT: VkRayTracingInvocationReorderModeEXT = 1;
pub const VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV: VkRayTracingInvocationReorderModeEXT = VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT;
pub const VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV: VkRayTracingLssIndexingModeNV = 0;
pub const VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV: VkRayTracingLssIndexingModeNV = 1;
pub const VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV: VkRayTracingLssPrimitiveEndCapsModeNV = 1;
pub const VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV: VkRayTracingLssPrimitiveEndCapsModeNV = 0;
pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR: VkRayTracingShaderGroupTypeKHR = 0;
pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV: VkRayTracingShaderGroupTypeKHR = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR;
pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR: VkRayTracingShaderGroupTypeKHR = 2;
pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV: VkRayTracingShaderGroupTypeKHR = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR;
pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR: VkRayTracingShaderGroupTypeKHR = 1;
pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV: VkRayTracingShaderGroupTypeKHR = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR;
pub const VK_REMAINING_3D_SLICES_EXT: u32 = !0;
pub const VK_REMAINING_ARRAY_LAYERS: u32 = !0;
pub const VK_REMAINING_MIP_LEVELS: u32 = !0;
pub const VK_RENDERING_ATTACHMENT_INPUT_ATTACHMENT_FEEDBACK_BIT_KHR: VkRenderingAttachmentFlagBitsKHR = 1 << 0;
pub const VK_RENDERING_ATTACHMENT_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR: VkRenderingAttachmentFlagBitsKHR = 1 << 2;
pub const VK_RENDERING_ATTACHMENT_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR: VkRenderingAttachmentFlagBitsKHR = 1 << 1;
pub const VK_RENDERING_CONTENTS_INLINE_BIT_EXT: VkRenderingFlagBits = VK_RENDERING_CONTENTS_INLINE_BIT_KHR;
pub const VK_RENDERING_CONTENTS_INLINE_BIT_KHR: VkRenderingFlagBits = 1 << 4;
pub const VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT: VkRenderingFlagBits = 1 << 0;
pub const VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR: VkRenderingFlagBits = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT;
pub const VK_RENDERING_CUSTOM_RESOLVE_BIT_EXT: VkRenderingFlagBits = 1 << 7;
pub const VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT: VkRenderingFlagBits = 1 << 3;
pub const VK_RENDERING_FRAGMENT_REGION_BIT_EXT: VkRenderingFlagBits = 1 << 6;
pub const VK_RENDERING_LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR: VkRenderingFlagBits = 1 << 8;
pub const VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE: VkRenderingFlagBits = 1 << 5;
pub const VK_RENDERING_RESUMING_BIT: VkRenderingFlagBits = 1 << 2;
pub const VK_RENDERING_RESUMING_BIT_KHR: VkRenderingFlagBits = VK_RENDERING_RESUMING_BIT;
pub const VK_RENDERING_SUSPENDING_BIT: VkRenderingFlagBits = 1 << 1;
pub const VK_RENDERING_SUSPENDING_BIT_KHR: VkRenderingFlagBits = VK_RENDERING_SUSPENDING_BIT;
pub const VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE: VkRenderPassCreateFlagBits = 1 << 2;
pub const VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM: VkRenderPassCreateFlagBits = 1 << 1;
pub const VK_RESOLVE_IMAGE_ENABLE_TRANSFER_FUNCTION_BIT_KHR: VkResolveImageFlagBitsKHR = 1 << 1;
pub const VK_RESOLVE_IMAGE_SKIP_TRANSFER_FUNCTION_BIT_KHR: VkResolveImageFlagBitsKHR = 1 << 0;
pub const VK_RESOLVE_MODE_AVERAGE_BIT: VkResolveModeFlagBits = 1 << 1;
pub const VK_RESOLVE_MODE_AVERAGE_BIT_KHR: VkResolveModeFlagBits = VK_RESOLVE_MODE_AVERAGE_BIT;
pub const VK_RESOLVE_MODE_CUSTOM_BIT_EXT: VkResolveModeFlagBits = 1 << 5;
pub const VK_RESOLVE_MODE_MAX_BIT: VkResolveModeFlagBits = 1 << 3;
pub const VK_RESOLVE_MODE_MAX_BIT_KHR: VkResolveModeFlagBits = VK_RESOLVE_MODE_MAX_BIT;
pub const VK_RESOLVE_MODE_MIN_BIT: VkResolveModeFlagBits = 1 << 2;
pub const VK_RESOLVE_MODE_MIN_BIT_KHR: VkResolveModeFlagBits = VK_RESOLVE_MODE_MIN_BIT;
pub const VK_RESOLVE_MODE_NONE: VkResolveModeFlagBits = 0;
pub const VK_RESOLVE_MODE_NONE_KHR: VkResolveModeFlagBits = VK_RESOLVE_MODE_NONE;
pub const VK_RESOLVE_MODE_SAMPLE_ZERO_BIT: VkResolveModeFlagBits = 1 << 0;
pub const VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR: VkResolveModeFlagBits = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT;
pub const VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER: VkSamplerAddressMode = 3;
pub const VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE: VkSamplerAddressMode = 2;
pub const VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT: VkSamplerAddressMode = 1;
pub const VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE: VkSamplerAddressMode = 4;
pub const VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR: VkSamplerAddressMode = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;
pub const VK_SAMPLER_ADDRESS_MODE_REPEAT: VkSamplerAddressMode = 0;
pub const VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkSamplerCreateFlagBits = 1 << 3;
pub const VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM: VkSamplerCreateFlagBits = 1 << 4;
pub const VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT: VkSamplerCreateFlagBits = 1 << 2;
pub const VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT: VkSamplerCreateFlagBits = 1 << 0;
pub const VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT: VkSamplerCreateFlagBits = 1 << 1;
pub const VK_SAMPLER_MIPMAP_MODE_LINEAR: VkSamplerMipmapMode = 1;
pub const VK_SAMPLER_MIPMAP_MODE_NEAREST: VkSamplerMipmapMode = 0;
pub const VK_SAMPLER_REDUCTION_MODE_MAX: VkSamplerReductionMode = 2;
pub const VK_SAMPLER_REDUCTION_MODE_MAX_EXT: VkSamplerReductionMode = VK_SAMPLER_REDUCTION_MODE_MAX;
pub const VK_SAMPLER_REDUCTION_MODE_MIN: VkSamplerReductionMode = 1;
pub const VK_SAMPLER_REDUCTION_MODE_MIN_EXT: VkSamplerReductionMode = VK_SAMPLER_REDUCTION_MODE_MIN;
pub const VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE: VkSamplerReductionMode = 0;
pub const VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT: VkSamplerReductionMode = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE;
pub const VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM: VkSamplerReductionMode = 1000521000;
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY: VkSamplerYcbcrModelConversion = 0;
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020: VkSamplerYcbcrModelConversion = 4;
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020;
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601: VkSamplerYcbcrModelConversion = 3;
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601;
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709: VkSamplerYcbcrModelConversion = 2;
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709;
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY: VkSamplerYcbcrModelConversion = 1;
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY;
pub const VK_SAMPLER_YCBCR_RANGE_ITU_FULL: VkSamplerYcbcrRange = 0;
pub const VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR: VkSamplerYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
pub const VK_SAMPLER_YCBCR_RANGE_ITU_NARROW: VkSamplerYcbcrRange = 1;
pub const VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR: VkSamplerYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW;
pub const VK_SAMPLE_COUNT_16_BIT: VkSampleCountFlagBits = 1 << 4;
pub const VK_SAMPLE_COUNT_1_BIT: VkSampleCountFlagBits = 1 << 0;
pub const VK_SAMPLE_COUNT_2_BIT: VkSampleCountFlagBits = 1 << 1;
pub const VK_SAMPLE_COUNT_32_BIT: VkSampleCountFlagBits = 1 << 5;
pub const VK_SAMPLE_COUNT_4_BIT: VkSampleCountFlagBits = 1 << 2;
pub const VK_SAMPLE_COUNT_64_BIT: VkSampleCountFlagBits = 1 << 6;
pub const VK_SAMPLE_COUNT_8_BIT: VkSampleCountFlagBits = 1 << 3;
pub const VK_SCOPE_DEVICE_KHR: VkScopeKHR = 1;
pub const VK_SCOPE_DEVICE_NV: VkScopeKHR = VK_SCOPE_DEVICE_KHR;
pub const VK_SCOPE_QUEUE_FAMILY_KHR: VkScopeKHR = 5;
pub const VK_SCOPE_QUEUE_FAMILY_NV: VkScopeKHR = VK_SCOPE_QUEUE_FAMILY_KHR;
pub const VK_SCOPE_SUBGROUP_KHR: VkScopeKHR = 3;
pub const VK_SCOPE_SUBGROUP_NV: VkScopeKHR = VK_SCOPE_SUBGROUP_KHR;
pub const VK_SCOPE_WORKGROUP_KHR: VkScopeKHR = 2;
pub const VK_SCOPE_WORKGROUP_NV: VkScopeKHR = VK_SCOPE_WORKGROUP_KHR;
pub const VK_SEC_AMIGO_PROFILING_EXTENSION_NAME: &CStr = c"VK_SEC_amigo_profiling";
pub const VK_SEC_AMIGO_PROFILING_SPEC_VERSION: u32 = 1;
pub const VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_EXTENSION_NAME: &CStr = c"VK_SEC_pipeline_cache_incremental_mode";
pub const VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION: u32 = 1;
pub const VK_SEMAPHORE_IMPORT_TEMPORARY_BIT: VkSemaphoreImportFlagBits = 1 << 0;
pub const VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR: VkSemaphoreImportFlagBits = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT;
pub const VK_SEMAPHORE_TYPE_BINARY: VkSemaphoreType = 0;
pub const VK_SEMAPHORE_TYPE_BINARY_KHR: VkSemaphoreType = VK_SEMAPHORE_TYPE_BINARY;
pub const VK_SEMAPHORE_TYPE_TIMELINE: VkSemaphoreType = 1;
pub const VK_SEMAPHORE_TYPE_TIMELINE_KHR: VkSemaphoreType = VK_SEMAPHORE_TYPE_TIMELINE;
pub const VK_SEMAPHORE_WAIT_ANY_BIT: VkSemaphoreWaitFlagBits = 1 << 0;
pub const VK_SEMAPHORE_WAIT_ANY_BIT_KHR: VkSemaphoreWaitFlagBits = VK_SEMAPHORE_WAIT_ANY_BIT;
pub const VK_SHADER_CODE_TYPE_BINARY_EXT: VkShaderCodeTypeEXT = 0;
pub const VK_SHADER_CODE_TYPE_SPIRV_EXT: VkShaderCodeTypeEXT = 1;
pub const VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 15;
pub const VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 1;
pub const VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 4;
pub const VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 6;
pub const VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 5;
pub const VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 7;
pub const VK_SHADER_CREATE_LINK_STAGE_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 0;
pub const VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 3;
pub const VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 2;
pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY: VkShaderFloatControlsIndependence = 0;
pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR: VkShaderFloatControlsIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY;
pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL: VkShaderFloatControlsIndependence = 1;
pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR: VkShaderFloatControlsIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL;
pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE: VkShaderFloatControlsIndependence = 2;
pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR: VkShaderFloatControlsIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE;
pub const VK_SHADER_GROUP_SHADER_ANY_HIT_KHR: VkShaderGroupShaderKHR = 2;
pub const VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR: VkShaderGroupShaderKHR = 1;
pub const VK_SHADER_GROUP_SHADER_GENERAL_KHR: VkShaderGroupShaderKHR = 0;
pub const VK_SHADER_GROUP_SHADER_INTERSECTION_KHR: VkShaderGroupShaderKHR = 3;
pub const VK_SHADER_INFO_TYPE_BINARY_AMD: VkShaderInfoTypeAMD = 1;
pub const VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD: VkShaderInfoTypeAMD = 2;
pub const VK_SHADER_INFO_TYPE_STATISTICS_AMD: VkShaderInfoTypeAMD = 0;
pub const VK_SHADER_STAGE_ALL: VkShaderStageFlagBits = 0x7FFFFFFF;
pub const VK_SHADER_STAGE_ALL_GRAPHICS: VkShaderStageFlagBits = 0x0000001F;
pub const VK_SHADER_STAGE_ANY_HIT_BIT_KHR: VkShaderStageFlagBits = 1 << 9;
pub const VK_SHADER_STAGE_ANY_HIT_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_ANY_HIT_BIT_KHR;
pub const VK_SHADER_STAGE_CALLABLE_BIT_KHR: VkShaderStageFlagBits = 1 << 13;
pub const VK_SHADER_STAGE_CALLABLE_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_CALLABLE_BIT_KHR;
pub const VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR: VkShaderStageFlagBits = 1 << 10;
pub const VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;
pub const VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI: VkShaderStageFlagBits = 1 << 19;
pub const VK_SHADER_STAGE_COMPUTE_BIT: VkShaderStageFlagBits = 1 << 5;
pub const VK_SHADER_STAGE_FRAGMENT_BIT: VkShaderStageFlagBits = 1 << 4;
pub const VK_SHADER_STAGE_GEOMETRY_BIT: VkShaderStageFlagBits = 1 << 3;
pub const VK_SHADER_STAGE_INTERSECTION_BIT_KHR: VkShaderStageFlagBits = 1 << 12;
pub const VK_SHADER_STAGE_INTERSECTION_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_INTERSECTION_BIT_KHR;
pub const VK_SHADER_STAGE_MESH_BIT_EXT: VkShaderStageFlagBits = 1 << 7;
pub const VK_SHADER_STAGE_MESH_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_MESH_BIT_EXT;
pub const VK_SHADER_STAGE_MISS_BIT_KHR: VkShaderStageFlagBits = 1 << 11;
pub const VK_SHADER_STAGE_MISS_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_MISS_BIT_KHR;
pub const VK_SHADER_STAGE_RAYGEN_BIT_KHR: VkShaderStageFlagBits = 1 << 8;
pub const VK_SHADER_STAGE_RAYGEN_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_RAYGEN_BIT_KHR;
pub const VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI: VkShaderStageFlagBits = 1 << 14;
pub const VK_SHADER_STAGE_TASK_BIT_EXT: VkShaderStageFlagBits = 1 << 6;
pub const VK_SHADER_STAGE_TASK_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_TASK_BIT_EXT;
pub const VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT: VkShaderStageFlagBits = 1 << 1;
pub const VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT: VkShaderStageFlagBits = 1 << 2;
pub const VK_SHADER_STAGE_VERTEX_BIT: VkShaderStageFlagBits = 1 << 0;
pub const VK_SHADER_UNUSED_KHR: u32 = !0;
pub const VK_SHADER_UNUSED_NV: u32 = VK_SHADER_UNUSED_KHR;
pub const VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = 1;
pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV: VkShadingRatePaletteEntryNV = 7;
pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV: VkShadingRatePaletteEntryNV = 6;
pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV: VkShadingRatePaletteEntryNV = 8;
pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV: VkShadingRatePaletteEntryNV = 10;
pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV: VkShadingRatePaletteEntryNV = 9;
pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV: VkShadingRatePaletteEntryNV = 11;
pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = 5;
pub const VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = 4;
pub const VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = 3;
pub const VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = 2;
pub const VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV: VkShadingRatePaletteEntryNV = 0;
pub const VK_SHARING_MODE_CONCURRENT: VkSharingMode = 1;
pub const VK_SHARING_MODE_EXCLUSIVE: VkSharingMode = 0;
pub const VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT: VkSparseImageFormatFlagBits = 1 << 1;
pub const VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT: VkSparseImageFormatFlagBits = 1 << 2;
pub const VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT: VkSparseImageFormatFlagBits = 1 << 0;
pub const VK_SPARSE_MEMORY_BIND_METADATA_BIT: VkSparseMemoryBindFlagBits = 1 << 0;
pub const VK_STENCIL_FACE_BACK_BIT: VkStencilFaceFlagBits = 1 << 1;
pub const VK_STENCIL_FACE_FRONT_AND_BACK: VkStencilFaceFlagBits = 0x00000003;
pub const VK_STENCIL_FACE_FRONT_BIT: VkStencilFaceFlagBits = 1 << 0;
pub const VK_STENCIL_FRONT_AND_BACK: VkStencilFaceFlagBits = VK_STENCIL_FACE_FRONT_AND_BACK;
pub const VK_STENCIL_OP_DECREMENT_AND_CLAMP: VkStencilOp = 4;
pub const VK_STENCIL_OP_DECREMENT_AND_WRAP: VkStencilOp = 7;
pub const VK_STENCIL_OP_INCREMENT_AND_CLAMP: VkStencilOp = 3;
pub const VK_STENCIL_OP_INCREMENT_AND_WRAP: VkStencilOp = 6;
pub const VK_STENCIL_OP_INVERT: VkStencilOp = 5;
pub const VK_STENCIL_OP_KEEP: VkStencilOp = 0;
pub const VK_STENCIL_OP_REPLACE: VkStencilOp = 2;
pub const VK_STENCIL_OP_ZERO: VkStencilOp = 1;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: VkStructureType = 1000150000;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: VkStructureType = 1000150020;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = 1000316009;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR: VkStructureType = 1000150017;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV: VkStructureType = 1000165001;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: VkStructureType = 1000150002;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: VkStructureType = 1000150003;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: VkStructureType = 1000150004;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR: VkStructureType = 1000150006;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV: VkStructureType = 1000429009;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: VkStructureType = 1000327000;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV: VkStructureType = 1000429010;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: VkStructureType = 1000150005;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV: VkStructureType = 1000165012;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: VkStructureType = 1000165008;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: VkStructureType = 1000327002;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: VkStructureType = 1000396009;
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR: VkStructureType = 1000150009;
pub const VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR: VkStructureType = 1000060010;
pub const VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR: VkStructureType = 1000116004;
pub const VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: VkStructureType = 1000485001;
pub const VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD: VkStructureType = 1000476001;
pub const VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD: VkStructureType = 1000476002;
pub const VK_STRUCTURE_TYPE_APPLICATION_INFO: VkStructureType = 0;
pub const VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2: VkStructureType = 1000109000;
pub const VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2;
pub const VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: VkStructureType = 1000241002;
pub const VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT;
pub const VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT: VkStructureType = 1000527001;
pub const VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2: VkStructureType = 1000109001;
pub const VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2;
pub const VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: VkStructureType = 1000241001;
pub const VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT;
pub const VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: VkStructureType = 1000044008;
pub const VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
pub const VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT: VkStructureType = 1000628001;
pub const VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: VkStructureType = 1000165006;
pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: VkStructureType = 1000060013;
pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO;
pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO: VkStructureType = 1000157000;
pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO;
pub const VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM: VkStructureType = 1000507005;
pub const VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT: VkStructureType = 1000545008;
pub const VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO: VkStructureType = 1000545003;
pub const VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO;
pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: VkStructureType = 1000060014;
pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO: VkStructureType = 1000157001;
pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO;
pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: VkStructureType = 1000060009;
pub const VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: VkStructureType = 1000156002;
pub const VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO;
pub const VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: VkStructureType = 1000545002;
pub const VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS;
pub const VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: VkStructureType = 7;
pub const VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM: VkStructureType = 1000460002;
pub const VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR: VkStructureType = 1000023004;
pub const VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM: VkStructureType = 1000519002;
pub const VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2: VkStructureType = 1000337004;
pub const VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2;
pub const VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = 1000316005;
pub const VK_STRUCTURE_TYPE_BUFFER_COPY_2: VkStructureType = 1000337006;
pub const VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_COPY_2;
pub const VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: VkStructureType = 12;
pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: VkStructureType = 1000244002;
pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO: VkStructureType = 1000244001;
pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT: VkStructureType = 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;
pub const VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2: VkStructureType = 1000337009;
pub const VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2;
pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: VkStructureType = 44;
pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2: VkStructureType = 1000314001;
pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2;
pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = 1000146000;
pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2;
pub const VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: VkStructureType = 1000257002;
pub const VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: VkStructureType = 1000470006;
pub const VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: VkStructureType = 13;
pub const VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV: VkStructureType = 1000570004;
pub const VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR;
pub const VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR: VkStructureType = 1000184000;
pub const VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV: VkStructureType = 1000314009;
pub const VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV: VkStructureType = 1000206000;
pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV: VkStructureType = 1000569002;
pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV: VkStructureType = 1000569006;
pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV: VkStructureType = 1000569005;
pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV: VkStructureType = 1000569004;
pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV: VkStructureType = 1000569003;
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: VkStructureType = 40;
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: VkStructureType = 42;
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: VkStructureType = 1000081000;
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: VkStructureType = 41;
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: VkStructureType = 1000044004;
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO;
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: VkStructureType = 1000282000;
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: VkStructureType = 1000278001;
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO: VkStructureType = 1000314006;
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
pub const VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: VkStructureType = 39;
pub const VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV: VkStructureType = 1000645000;
pub const VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: VkStructureType = 29;
pub const VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV: VkStructureType = 1000428001;
pub const VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT: VkStructureType = 1000081002;
pub const VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV: VkStructureType = 1000491004;
pub const VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV: VkStructureType = 1000593001;
pub const VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR: VkStructureType = 1000506001;
pub const VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV: VkStructureType = 1000249001;
pub const VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV: VkStructureType = 1000491002;
pub const VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR: VkStructureType = 1000150010;
pub const VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: VkStructureType = 1000150011;
pub const VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2: VkStructureType = 1000337000;
pub const VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2;
pub const VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2: VkStructureType = 1000337002;
pub const VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2;
pub const VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: VkStructureType = 1000333000;
pub const VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: VkStructureType = 36;
pub const VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2: VkStructureType = 1000337001;
pub const VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2;
pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2: VkStructureType = 1000337003;
pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2;
pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO: VkStructureType = 1000270007;
pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO;
pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO: VkStructureType = 1000270004;
pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO;
pub const VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR: VkStructureType = 1000549002;
pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: VkStructureType = 1000150012;
pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR: VkStructureType = 1000549003;
pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO: VkStructureType = 1000270005;
pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO;
pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT: VkStructureType = 1000396004;
pub const VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT: VkStructureType = 1000396002;
pub const VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT: VkStructureType = 1000396003;
pub const VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM: VkStructureType = 1000460011;
pub const VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT: VkStructureType = 1000628002;
pub const VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX: VkStructureType = 1000029001;
pub const VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX: VkStructureType = 1000029002;
pub const VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX: VkStructureType = 1000029000;
pub const VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX: VkStructureType = 1000029004;
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM: VkStructureType = 1000629001;
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM: VkStructureType = 1000507010;
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM: VkStructureType = 1000507003;
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM: VkStructureType = 1000507015;
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM: VkStructureType = 1000507000;
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM: VkStructureType = 1000507014;
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM: VkStructureType = 1000507013;
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM: VkStructureType = 1000507009;
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM: VkStructureType = 1000507008;
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM: VkStructureType = 1000507002;
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM: VkStructureType = 1000507011;
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM: VkStructureType = 1000507012;
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM: VkStructureType = 1000507001;
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM: VkStructureType = 1000507004;
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM: VkStructureType = 1000507007;
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: VkStructureType = 1000507016;
pub const VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT: VkStructureType = 1000022002;
pub const VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT: VkStructureType = 1000022000;
pub const VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT: VkStructureType = 1000022001;
pub const VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: VkStructureType = 1000011000;
pub const VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT: VkStructureType = 1000128002;
pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: VkStructureType = 1000128003;
pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: VkStructureType = 1000128004;
pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: VkStructureType = 1000128000;
pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT: VkStructureType = 1000128001;
pub const VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT: VkStructureType = 1000550002;
pub const VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: VkStructureType = 1000026001;
pub const VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: VkStructureType = 1000026000;
pub const VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: VkStructureType = 1000026002;
pub const VK_STRUCTURE_TYPE_DEPENDENCY_INFO: VkStructureType = 1000314003;
pub const VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
pub const VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT: VkStructureType = 1000283001;
pub const VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT: VkStructureType = 1000283002;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT: VkStructureType = 1000316003;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT: VkStructureType = 1000316011;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: VkStructureType = 1000316012;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT: VkStructureType = 1000316004;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM: VkStructureType = 1000460020;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: VkStructureType = 33;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: VkStructureType = 1000138003;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: VkStructureType = 34;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE: VkStructureType = 1000420001;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: VkStructureType = 1000161000;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: VkStructureType = 32;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: VkStructureType = 1000420002;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT: VkStructureType = 1000168001;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: VkStructureType = 1000161003;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: VkStructureType = 1000161004;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: VkStructureType = 1000085000;
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: VkStructureType = 1000354001;
pub const VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS: VkStructureType = 1000413002;
pub const VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS;
pub const VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: VkStructureType = 3;
pub const VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: VkStructureType = 1000284001;
pub const VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: VkStructureType = 1000300001;
pub const VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT: VkStructureType = 1000091001;
pub const VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT: VkStructureType = 1000341001;
pub const VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT: VkStructureType = 1000341002;
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: VkStructureType = 1000060006;
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO;
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: VkStructureType = 1000060004;
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO;
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: VkStructureType = 1000070001;
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: VkStructureType = 1000060007;
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: VkStructureType = 1000060011;
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: VkStructureType = 1000060003;
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: VkStructureType = 1000060005;
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO;
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000060012;
pub const VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS: VkStructureType = 1000413003;
pub const VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS;
pub const VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO: VkStructureType = 1000470004;
pub const VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO;
pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: VkStructureType = 1000257004;
pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO;
pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: VkStructureType = 1000189000;
pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: VkStructureType = 1000284002;
pub const VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: VkStructureType = 1000483008;
pub const VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: VkStructureType = 1000295001;
pub const VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: VkStructureType = 2;
pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: VkStructureType = 1000174000;
pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: VkStructureType = 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;
pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2: VkStructureType = 1000145003;
pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: VkStructureType = 1000417000;
pub const VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM: VkStructureType = 1000460010;
pub const VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG: VkStructureType = 1000459000;
pub const VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: VkStructureType = 1000459001;
pub const VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM: VkStructureType = 1000309005;
pub const VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT: VkStructureType = 1000091002;
pub const VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR: VkStructureType = 1000002000;
pub const VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR: VkStructureType = 1000121002;
pub const VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV: VkStructureType = 1000551001;
pub const VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: VkStructureType = 1000213000;
pub const VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR: VkStructureType = 1000121004;
pub const VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR: VkStructureType = 1000121003;
pub const VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR: VkStructureType = 1000121001;
pub const VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT: VkStructureType = 1000091000;
pub const VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: VkStructureType = 1000003000;
pub const VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR: VkStructureType = 1000121000;
pub const VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000002001;
pub const VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV: VkStructureType = 1000551000;
pub const VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: VkStructureType = 1000158006;
pub const VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: VkStructureType = 1000158000;
pub const VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: VkStructureType = 10;
pub const VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: VkStructureType = 1000113000;
pub const VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: VkStructureType = 1000072002;
pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: VkStructureType = 1000056001;
pub const VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: VkStructureType = 1000077000;
pub const VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES: VkStructureType = 1000071003;
pub const VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES;
pub const VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV: VkStructureType = 1000556001;
pub const VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV: VkStructureType = 1000556002;
pub const VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV: VkStructureType = 1000556000;
pub const VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES: VkStructureType = 1000112001;
pub const VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES;
pub const VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: VkStructureType = 1000071001;
pub const VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: VkStructureType = 1000453000;
pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: VkStructureType = 1000072000;
pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: VkStructureType = 1000072001;
pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: VkStructureType = 1000056000;
pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM: VkStructureType = 1000460017;
pub const VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES: VkStructureType = 1000076001;
pub const VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES;
pub const VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM: VkStructureType = 1000460016;
pub const VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: VkStructureType = 8;
pub const VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR: VkStructureType = 1000115001;
pub const VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: VkStructureType = 1000170001;
pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2: VkStructureType = 1000059002;
pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: VkStructureType = 1000360000;
pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: VkStructureType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
pub const VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: VkStructureType = 1000226000;
pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: VkStructureType = 1000108001;
pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: VkStructureType = 1000108002;
pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO;
pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: VkStructureType = 37;
pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: VkStructureType = 1000250002;
pub const VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: VkStructureType = 1000375001;
pub const VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: VkStructureType = 1000460023;
pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT: VkStructureType = 1000572004;
pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV: VkStructureType = 1000277005;
pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT: VkStructureType = 1000572002;
pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: VkStructureType = 1000277006;
pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: VkStructureType = 1000572013;
pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: VkStructureType = 1000572014;
pub const VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV: VkStructureType = 1000165005;
pub const VK_STRUCTURE_TYPE_GEOMETRY_NV: VkStructureType = 1000165003;
pub const VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV: VkStructureType = 1000165004;
pub const VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV: VkStructureType = 1000505003;
pub const VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: VkStructureType = 28;
pub const VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: VkStructureType = 1000320002;
pub const VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: VkStructureType = 1000277002;
pub const VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: VkStructureType = 1000277001;
pub const VK_STRUCTURE_TYPE_HDR_METADATA_EXT: VkStructureType = 1000105000;
pub const VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI: VkStructureType = 1000590001;
pub const VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT: VkStructureType = 1000256000;
pub const VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: VkStructureType = 1000270009;
pub const VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: VkStructureType = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY;
pub const VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO: VkStructureType = 1000270006;
pub const VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO;
pub const VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: VkStructureType = 1000575002;
pub const VK_STRUCTURE_TYPE_IMAGE_BLIT_2: VkStructureType = 1000337008;
pub const VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2;
pub const VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = 1000316006;
pub const VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: VkStructureType = 1000338001;
pub const VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: VkStructureType = 1000338004;
pub const VK_STRUCTURE_TYPE_IMAGE_COPY_2: VkStructureType = 1000337007;
pub const VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_COPY_2;
pub const VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: VkStructureType = 14;
pub const VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: VkStructureType = 1000158004;
pub const VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: VkStructureType = 1000158003;
pub const VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: VkStructureType = 1000158005;
pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: VkStructureType = 1000147000;
pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2: VkStructureType = 1000059003;
pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: VkStructureType = 45;
pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2: VkStructureType = 1000314002;
pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = 1000146001;
pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2;
pub const VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: VkStructureType = 1000156003;
pub const VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO;
pub const VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2: VkStructureType = 1000337010;
pub const VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2;
pub const VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = 1000146002;
pub const VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2;
pub const VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: VkStructureType = 1000246000;
pub const VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2: VkStructureType = 1000338003;
pub const VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2;
pub const VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2;
pub const VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000060008;
pub const VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY: VkStructureType = 1000270003;
pub const VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY;
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: VkStructureType = 1000030001;
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: VkStructureType = 1000067000;
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = 1000316007;
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: VkStructureType = 15;
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX: VkStructureType = 1000030000;
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: VkStructureType = 1000391001;
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: VkStructureType = 1000440002;
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: VkStructureType = 1000418001;
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: VkStructureType = 1000117002;
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR: VkStructureType = 1000115000;
pub const VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: VkStructureType = 1000074000;
pub const VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: VkStructureType = 1000178000;
pub const VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: VkStructureType = 1000079000;
pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT: VkStructureType = 1000572006;
pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: VkStructureType = 1000277004;
pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT: VkStructureType = 1000572007;
pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: VkStructureType = 1000277003;
pub const VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT: VkStructureType = 1000572003;
pub const VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT: VkStructureType = 1000572010;
pub const VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT: VkStructureType = 1000572011;
pub const VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT: VkStructureType = 1000572012;
pub const VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL: VkStructureType = 1000210001;
pub const VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: VkStructureType = 1;
pub const VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV: VkStructureType = 1000505001;
pub const VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV: VkStructureType = 1000505000;
pub const VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV: VkStructureType = 1000505005;
pub const VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: VkStructureType = 1000505008;
pub const VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV: VkStructureType = 1000505004;
pub const VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: VkStructureType = 1000496000;
pub const VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: VkStructureType = 48;
pub const VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: VkStructureType = 47;
pub const VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: VkStructureType = 6;
pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: VkStructureType = 1000060000;
pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO;
pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: VkStructureType = 5;
pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER: VkStructureType = 46;
pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: VkStructureType = 1000314000;
pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2;
pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: VkStructureType = 1000574002;
pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: VkStructureType = 1000127001;
pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: VkStructureType = 1000460014;
pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: VkStructureType = 1000127000;
pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
pub const VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR: VkStructureType = 1000074001;
pub const VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: VkStructureType = 1000074002;
pub const VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV: VkStructureType = 1000371000;
pub const VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT: VkStructureType = 1000178001;
pub const VK_STRUCTURE_TYPE_MEMORY_MAP_INFO: VkStructureType = 1000271000;
pub const VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO;
pub const VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT: VkStructureType = 1000272002;
pub const VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: VkStructureType = 1000257003;
pub const VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
pub const VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: VkStructureType = 1000238001;
pub const VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2: VkStructureType = 1000146003;
pub const VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2;
pub const VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY: VkStructureType = 1000270002;
pub const VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY;
pub const VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO: VkStructureType = 1000271001;
pub const VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO;
pub const VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT: VkStructureType = 1000396000;
pub const VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT: VkStructureType = 1000396008;
pub const VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT: VkStructureType = 1000396007;
pub const VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT: VkStructureType = 1000396001;
pub const VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: VkStructureType = 1000376002;
pub const VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT: VkStructureType = 1000143004;
pub const VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: VkStructureType = 1000044009;
pub const VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: VkStructureType = 1000510001;
pub const VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: VkStructureType = 1000351002;
pub const VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: VkStructureType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
pub const VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: VkStructureType = 1000316010;
pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV: VkStructureType = 1000464005;
pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: VkStructureType = 1000464002;
pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV: VkStructureType = 1000464003;
pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV: VkStructureType = 1000464004;
pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: VkStructureType = 1000464010;
pub const VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV: VkStructureType = 1000505006;
pub const VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV: VkStructureType = 1000570005;
pub const VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV: VkStructureType = 1000570003;
pub const VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT: VkStructureType = 1000208007;
pub const VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT: VkStructureType = 1000208005;
pub const VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT: VkStructureType = 1000208006;
pub const VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: VkStructureType = 1000210005;
pub const VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM: VkStructureType = 1000605002;
pub const VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM: VkStructureType = 1000605003;
pub const VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR: VkStructureType = 1000116006;
pub const VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR: VkStructureType = 1000116005;
pub const VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL: VkStructureType = 1000210002;
pub const VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL: VkStructureType = 1000210004;
pub const VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: VkStructureType = 1000116003;
pub const VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL: VkStructureType = 1000210003;
pub const VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM: VkStructureType = 1000309003;
pub const VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM: VkStructureType = 1000309004;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: VkStructureType = 1000083000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: VkStructureType = 1000340000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: VkStructureType = 1000177000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: VkStructureType = 1000150013;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: VkStructureType = 1000150014;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: VkStructureType = 1000354000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: VkStructureType = 1000485000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: VkStructureType = 1000476000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: VkStructureType = 1000067001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: VkStructureType = 1000524000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: VkStructureType = 1000339000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: VkStructureType = 1000148000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: VkStructureType = 1000148001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: VkStructureType = 1000411000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: VkStructureType = 1000257000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: VkStructureType = 1000244000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: VkStructureType = 1000569000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV: VkStructureType = 1000569001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: VkStructureType = 1000404000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: VkStructureType = 1000404001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: VkStructureType = 1000404002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: VkStructureType = 1000229000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: VkStructureType = 1000381000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: VkStructureType = 1000559000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV: VkStructureType = 1000645001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: VkStructureType = 1000201000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR: VkStructureType = 1000511000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: VkStructureType = 1000081001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: VkStructureType = 1000101000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: VkStructureType = 1000593000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: VkStructureType = 1000593002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: VkStructureType = 1000506000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: VkStructureType = 1000249000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: VkStructureType = 1000506002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: VkStructureType = 1000249002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: VkStructureType = 1000491000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV: VkStructureType = 1000491001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: VkStructureType = 1000549000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: VkStructureType = 1000426000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR: VkStructureType = 1000426001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: VkStructureType = 1000050000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: VkStructureType = 1000250000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: VkStructureType = 1000521000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: VkStructureType = 1000519001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: VkStructureType = 1000287002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: VkStructureType = 1000287001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT: VkStructureType = 1000628000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: VkStructureType = 1000507006;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM: VkStructureType = 1000629000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: VkStructureType = 1000240000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: VkStructureType = 1000283000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: VkStructureType = 1000582000;
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;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: VkStructureType = 1000421000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: VkStructureType = 1000355000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: VkStructureType = 1000102000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: VkStructureType = 1000199000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: VkStructureType = 1000316001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: VkStructureType = 1000316002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: VkStructureType = 1000316000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: VkStructureType = 1000460018;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: VkStructureType = 1000460019;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: VkStructureType = 1000161001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: VkStructureType = 1000161002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: VkStructureType = 1000546000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: VkStructureType = 1000420000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: VkStructureType = 1000428000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: VkStructureType = 1000572000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: VkStructureType = 1000277007;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: VkStructureType = 1000572001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: VkStructureType = 1000277000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: VkStructureType = 1000284000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: VkStructureType = 1000300000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: VkStructureType = 1000099000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: VkStructureType = 1000196000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: VkStructureType = 1000353000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: VkStructureType = 1000044003;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: VkStructureType = 1000232000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: VkStructureType = 1000499000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: VkStructureType = 1000205002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: VkStructureType = 1000377000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: VkStructureType = 1000455000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: VkStructureType = 1000455001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: VkStructureType = 1000267000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: VkStructureType = 1000492000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: VkStructureType = 1000492001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: VkStructureType = 1000071002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV: VkStructureType = 1000556003;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: VkStructureType = 1000112000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: VkStructureType = 1000071000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: VkStructureType = 1000178002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: VkStructureType = 1000371001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: VkStructureType = 1000076000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM: VkStructureType = 1000460015;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: VkStructureType = 1000341000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: VkStructureType = 1000059000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: VkStructureType = 1000197000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: VkStructureType = 1000609000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: VkStructureType = 1000332000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: VkStructureType = 1000332001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: VkStructureType = 1000218000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: VkStructureType = 1000611000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE: VkStructureType = 1000611001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: VkStructureType = 1000425000;
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;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT: VkStructureType = 1000425001;
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;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: VkStructureType = 1000218001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: VkStructureType = 1000203000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: VkStructureType = 1000322000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: VkStructureType = 1000251000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: VkStructureType = 1000326001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: VkStructureType = 1000326000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: VkStructureType = 1000226003;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: VkStructureType = 1000226004;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: VkStructureType = 1000226002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: VkStructureType = 1000375000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: VkStructureType = 1000388000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: VkStructureType = 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;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: VkStructureType = 1000320000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: VkStructureType = 1000320001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES: VkStructureType = 1000070000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: VkStructureType = 1000590000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: VkStructureType = 1000270000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: VkStructureType = 1000270001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: VkStructureType = 1000261000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: VkStructureType = 1000071004;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: VkStructureType = 1000108000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: VkStructureType = 1000393000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: VkStructureType = 1000575000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA: VkStructureType = 1000575001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: VkStructureType = 1000338000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: VkStructureType = 1000437000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: VkStructureType = 1000158002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: VkStructureType = 1000059004;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: VkStructureType = 1000518000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: VkStructureType = 1000518001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: VkStructureType = 1000440000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: VkStructureType = 1000440001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: VkStructureType = 1000335000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: VkStructureType = 1000418000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: VkStructureType = 1000170000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: VkStructureType = 1000391000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: VkStructureType = 1000265000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: VkStructureType = 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;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: VkStructureType = 1000278000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: VkStructureType = 1000138000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: VkStructureType = 1000138001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: VkStructureType = 1000370000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR: VkStructureType = 1000562003;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR: VkStructureType = 1000562002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR: VkStructureType = 1000562004;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: VkStructureType = 1000530000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: VkStructureType = 1000465000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: VkStructureType = 1000495000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT: VkStructureType = 1000495001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: VkStructureType = 1000430000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: VkStructureType = 1000259000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: VkStructureType = 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;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: VkStructureType = 1000259002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: VkStructureType = 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;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR: VkStructureType = 1000630000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR: VkStructureType = 1000630001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: VkStructureType = 1000168000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: VkStructureType = 1000413000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: VkStructureType = 1000413001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: VkStructureType = 1000470000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: VkStructureType = 1000470001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: VkStructureType = 1000545000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: VkStructureType = 1000545001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR: VkStructureType = 1000562000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR: VkStructureType = 1000562001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: VkStructureType = 1000574000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: VkStructureType = 1000584000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: VkStructureType = 1000584001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: VkStructureType = 1000272000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: VkStructureType = 1000272001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: VkStructureType = 1000237000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT: VkStructureType = 1000427000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT: VkStructureType = 1000427001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: VkStructureType = 1000238000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: VkStructureType = 1000059006;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: VkStructureType = 1000328000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: VkStructureType = 1000202000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: VkStructureType = 1000328001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: VkStructureType = 1000202001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: VkStructureType = 1000376000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: VkStructureType = 1000053001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: VkStructureType = 1000097000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: VkStructureType = 1000510000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: VkStructureType = 1000488000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: VkStructureType = 1000053002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: VkStructureType = 1000392000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: VkStructureType = 1000392001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: VkStructureType = 1000351000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: VkStructureType = 1000451000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: VkStructureType = 1000451001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: VkStructureType = 1000422000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: VkStructureType = 1000396005;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: VkStructureType = 1000396006;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: VkStructureType = 1000464000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: VkStructureType = 1000464001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: VkStructureType = 1000412000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: VkStructureType = 1000570000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV: VkStructureType = 1000570001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: VkStructureType = 1000212000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM: VkStructureType = 1000605000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM: VkStructureType = 1000605001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: VkStructureType = 1000116000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: VkStructureType = 1000116001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: VkStructureType = 1000516000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: VkStructureType = 1000483000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: VkStructureType = 1000483004;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: VkStructureType = 1000637000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: VkStructureType = 1000297000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: VkStructureType = 1000269000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: VkStructureType = 1000498000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: VkStructureType = 1000596000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: VkStructureType = 1000372001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: VkStructureType = 1000466000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: VkStructureType = 1000068001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: VkStructureType = 1000068002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: VkStructureType = 1000117000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: VkStructureType = 1000292000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: VkStructureType = 1000479002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: VkStructureType = 1000294001;
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;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: VkStructureType = 1000361000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: VkStructureType = 1000208000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: VkStructureType = 1000480001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: VkStructureType = 1000248000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: VkStructureType = 1000382000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: VkStructureType = 1000356000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: VkStructureType = 1000295000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: VkStructureType = 1000059001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: VkStructureType = 1000145001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: VkStructureType = 1000145002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: VkStructureType = 1000254000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: VkStructureType = 1000254002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: VkStructureType = 1000080000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM: VkStructureType = 1000507019;
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;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: VkStructureType = 1000342000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: VkStructureType = 1000555000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: VkStructureType = 1000348013;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT: VkStructureType = 1000581000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: VkStructureType = 1000490000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT: VkStructureType = 1000581001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: VkStructureType = 1000490001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV: VkStructureType = 1000429008;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: VkStructureType = 1000386000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: VkStructureType = 1000327001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: VkStructureType = 1000347000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: VkStructureType = 1000347001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: VkStructureType = 1000481000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: VkStructureType = 1000165009;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: VkStructureType = 1000568000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: VkStructureType = 1000110000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: VkStructureType = 1000424000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: VkStructureType = 1000424001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: VkStructureType = 1000166000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: VkStructureType = 1000344000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: VkStructureType = 1000286000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR: VkStructureType = 1000286001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: VkStructureType = 1000130000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: VkStructureType = 1000156004;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: VkStructureType = 1000143003;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: VkStructureType = 1000221000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: VkStructureType = 1000417001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: VkStructureType = 1000417002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: VkStructureType = 1000241000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT: VkStructureType = 1000627000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: VkStructureType = 1000563000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: VkStructureType = 1000273000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: VkStructureType = 1000260000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: VkStructureType = 1000180000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: VkStructureType = 1000141000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: VkStructureType = 1000181000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: VkStructureType = 1000497000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: VkStructureType = 1000497001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: VkStructureType = 1000227000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: VkStructureType = 1000185000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: VkStructureType = 1000415000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: VkStructureType = 1000276000;
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;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: VkStructureType = 1000063000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: VkStructureType = 1000321000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: VkStructureType = 1000544000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: VkStructureType = 1000082000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: VkStructureType = 1000567000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: VkStructureType = 1000528000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR: VkStructureType = 1000579000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: VkStructureType = 1000234000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: VkStructureType = 1000204000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: VkStructureType = 1000280000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: VkStructureType = 1000280001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: VkStructureType = 1000209000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT: VkStructureType = 1000635000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT: VkStructureType = 1000635001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: VkStructureType = 1000434000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: VkStructureType = 1000462000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: VkStructureType = 1000462001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: VkStructureType = 1000482000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: VkStructureType = 1000482001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: VkStructureType = 1000235000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: VkStructureType = 1000558000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: VkStructureType = 1000564000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: VkStructureType = 1000154000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: VkStructureType = 1000154001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: VkStructureType = 1000175000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: VkStructureType = 1000416000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: VkStructureType = 1000323000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: VkStructureType = 1000215000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: VkStructureType = 1000395000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: VkStructureType = 1000395001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT: VkStructureType = 1000642000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: VkStructureType = 1000387000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: VkStructureType = 1000164001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: VkStructureType = 1000164002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: VkStructureType = 1000059008;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: VkStructureType = 1000094000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: VkStructureType = 1000225002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: VkStructureType = 1000225000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: VkStructureType = 1000458000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: VkStructureType = 1000369001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: VkStructureType = 1000369002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: VkStructureType = 1000119000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: VkStructureType = 1000275000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: VkStructureType = 1000314007;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: VkStructureType = 1000460009;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: VkStructureType = 1000460004;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: VkStructureType = 1000281000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: VkStructureType = 1000281001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT: VkStructureType = 1000288000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: VkStructureType = 1000066000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: VkStructureType = 1000547000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM: VkStructureType = 1000547001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: VkStructureType = 1000484000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: VkStructureType = 1000309000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM: VkStructureType = 1000309001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: VkStructureType = 1000207000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: VkStructureType = 1000207001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES: VkStructureType = 1000245000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: VkStructureType = 1000028000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: VkStructureType = 1000028001;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: VkStructureType = 1000527000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: VkStructureType = 1000253000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: VkStructureType = 1000120000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR: VkStructureType = 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;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: VkStructureType = 1000190002;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: VkStructureType = 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;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: VkStructureType = 1000525000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: VkStructureType = 1000190000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: VkStructureType = 1000608000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: VkStructureType = 1000352000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: VkStructureType = 1000514000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: VkStructureType = 1000513004;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: VkStructureType = 1000552004;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: VkStructureType = 1000299006;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: VkStructureType = 1000553009;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: VkStructureType = 1000390000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: VkStructureType = 1000023014;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: VkStructureType = 1000515000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: VkStructureType = 1000586000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: VkStructureType = 49;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: VkStructureType = 50;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: VkStructureType = 51;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: VkStructureType = 52;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: VkStructureType = 53;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: VkStructureType = 54;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: VkStructureType = 55;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: VkStructureType = 56;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: VkStructureType = 1000211000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: VkStructureType = 1000336000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: VkStructureType = 1000330000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: VkStructureType = 1000520000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: VkStructureType = 1000252000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: VkStructureType = 1000620000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: VkStructureType = 1000325000;
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR: VkStructureType = 1000483001;
pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR: VkStructureType = 1000483006;
pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR: VkStructureType = 1000483009;
pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: VkStructureType = 1000483002;
pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR: VkStructureType = 1000483003;
pub const VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: VkStructureType = 17;
pub const VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: VkStructureType = 1000148002;
pub const VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: VkStructureType = 26;
pub const VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: VkStructureType = 1000381001;
pub const VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: VkStructureType = 1000183000;
pub const VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: VkStructureType = 1000152000;
pub const VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: VkStructureType = 1000250001;
pub const VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: VkStructureType = 1000149000;
pub const VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: VkStructureType = 1000470005;
pub const VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR: VkStructureType = 1000483007;
pub const VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: VkStructureType = 1000192000;
pub const VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: VkStructureType = 25;
pub const VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: VkStructureType = 1000099001;
pub const VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: VkStructureType = 27;
pub const VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR: VkStructureType = 1000269003;
pub const VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: VkStructureType = 1000269005;
pub const VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR: VkStructureType = 1000269002;
pub const VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR: VkStructureType = 1000269004;
pub const VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: VkStructureType = 1000611002;
pub const VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: VkStructureType = 1000326002;
pub const VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: VkStructureType = 1000226001;
pub const VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV: VkStructureType = 1000428002;
pub const VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR;
pub const VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR: VkStructureType = 1000269001;
pub const VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: VkStructureType = 20;
pub const VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: VkStructureType = 30;
pub const VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: VkStructureType = 1000290000;
pub const VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: VkStructureType = 24;
pub const VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT: VkStructureType = 1000372000;
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: VkStructureType = 1000101001;
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: VkStructureType = 1000102001;
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: VkStructureType = 1000259001;
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: VkStructureType = 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;
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: VkStructureType = 1000254001;
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: VkStructureType = 23;
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: VkStructureType = 1000018000;
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: VkStructureType = 1000028002;
pub const VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: VkStructureType = 1000044002;
pub const VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: VkStructureType = 1000166001;
pub const VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: VkStructureType = 1000068000;
pub const VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: VkStructureType = 1000143002;
pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: VkStructureType = 18;
pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: VkStructureType = 1000462002;
pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: VkStructureType = 1000225001;
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;
pub const VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: VkStructureType = 1000117003;
pub const VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: VkStructureType = 21;
pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: VkStructureType = 1000190001;
pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: VkStructureType = 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;
pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: VkStructureType = 19;
pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: VkStructureType = 1000164005;
pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: VkStructureType = 1000582001;
pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: VkStructureType = 1000355001;
pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: VkStructureType = 1000205000;
pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: VkStructureType = 1000164000;
pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: VkStructureType = 22;
pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: VkStructureType = 1000098000;
pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: VkStructureType = 1000087000;
pub const VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR: VkStructureType = 1000479001;
pub const VK_STRUCTURE_TYPE_PRESENT_ID_KHR: VkStructureType = 1000294000;
pub const VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: VkStructureType = 1000001001;
pub const VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: VkStructureType = 1000084000;
pub const VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: VkStructureType = 1000092000;
pub const VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT: VkStructureType = 1000208003;
pub const VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT: VkStructureType = 1000208004;
pub const VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT: VkStructureType = 1000208008;
pub const VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR: VkStructureType = 1000480002;
pub const VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO: VkStructureType = 1000295002;
pub const VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: VkStructureType = 1000145000;
pub const VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO: VkStructureType = 1000545004;
pub const VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO;
pub const VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO: VkStructureType = 1000545005;
pub const VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO;
pub const VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO: VkStructureType = 1000545006;
pub const VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO;
pub const VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: VkStructureType = 1000310000;
pub const VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: VkStructureType = 11;
pub const VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL: VkStructureType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL;
pub const VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: VkStructureType = 1000116002;
pub const VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: VkStructureType = 1000210000;
pub const VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: VkStructureType = 1000299005;
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: VkStructureType = 1000314008;
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: VkStructureType = 1000206001;
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM: VkStructureType = 1000507017;
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM: VkStructureType = 1000507018;
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: VkStructureType = 1000388001;
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: VkStructureType = 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;
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: VkStructureType = 1000584002;
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2: VkStructureType = 1000059005;
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: VkStructureType = 1000023016;
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: VkStructureType = 1000023012;
pub const VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV: VkStructureType = 1000569007;
pub const VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR: VkStructureType = 1000150015;
pub const VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV: VkStructureType = 1000165000;
pub const VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: VkStructureType = 1000150018;
pub const VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: VkStructureType = 1000150016;
pub const VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: VkStructureType = 1000165011;
pub const VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR: VkStructureType = 1000483005;
pub const VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR;
pub const VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR: VkStructureType = 1000275005;
pub const VK_STRUCTURE_TYPE_RENDERING_AREA_INFO: VkStructureType = 1000470003;
pub const VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO;
pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR: VkStructureType = 1000630002;
pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO: VkStructureType = 1000044001;
pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: VkStructureType = 1000232001;
pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO;
pub const VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR;
pub const VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR: VkStructureType = 1000619003;
pub const VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: VkStructureType = 1000044007;
pub const VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: VkStructureType = 1000044006;
pub const VK_STRUCTURE_TYPE_RENDERING_INFO: VkStructureType = 1000044000;
pub const VK_STRUCTURE_TYPE_RENDERING_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_INFO;
pub const VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: VkStructureType = 1000232002;
pub const VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: VkStructureType = 1000108003;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: VkStructureType = 43;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: VkStructureType = 38;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: VkStructureType = 1000109004;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: VkStructureType = 1000458001;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: VkStructureType = 1000458002;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: VkStructureType = 1000218002;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT: VkStructureType = 1000425002;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: VkStructureType = 1000117001;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: VkStructureType = 1000053000;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM: VkStructureType = 1000605004;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: VkStructureType = 1000143001;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: VkStructureType = 1000424002;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM: VkStructureType = 1000424003;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: VkStructureType = 1000424004;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: VkStructureType = 1000458003;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: VkStructureType = 1000309002;
pub const VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: VkStructureType = 1000282001;
pub const VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2: VkStructureType = 1000337005;
pub const VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2;
pub const VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR: VkStructureType = 1000630004;
pub const VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: VkStructureType = 1000518002;
pub const VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: VkStructureType = 1000411001;
pub const VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = 1000316008;
pub const VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: VkStructureType = 31;
pub const VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: VkStructureType = 1000519000;
pub const VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: VkStructureType = 1000287000;
pub const VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: VkStructureType = 1000130001;
pub const VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO: VkStructureType = 1000156000;
pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: VkStructureType = 1000156005;
pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: VkStructureType = 1000156001;
pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM: VkStructureType = 1000520001;
pub const VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: VkStructureType = 1000143000;
pub const VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: VkStructureType = 9;
pub const VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: VkStructureType = 1000079001;
pub const VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO: VkStructureType = 1000207005;
pub const VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO;
pub const VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO: VkStructureType = 1000314005;
pub const VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO;
pub const VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: VkStructureType = 1000207002;
pub const VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO: VkStructureType = 1000207004;
pub const VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO;
pub const VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT: VkStructureType = 1000545007;
pub const VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV: VkStructureType = 1000505002;
pub const VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT: VkStructureType = 1000482002;
pub const VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: VkStructureType = 16;
pub const VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT: VkStructureType = 1000462003;
pub const VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: VkStructureType = 1000160001;
pub const VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
pub const VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: VkStructureType = 1000111000;
pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2: VkStructureType = 1000059007;
pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2;
pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: VkStructureType = 1000146004;
pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2;
pub const VK_STRUCTURE_TYPE_SUBMIT_INFO: VkStructureType = 4;
pub const VK_STRUCTURE_TYPE_SUBMIT_INFO_2: VkStructureType = 1000314004;
pub const VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2;
pub const VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO: VkStructureType = 1000109005;
pub const VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO;
pub const VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2: VkStructureType = 1000109003;
pub const VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2;
pub const VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2: VkStructureType = 1000109002;
pub const VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2;
pub const VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: VkStructureType = 1000199001;
pub const VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
pub const VK_STRUCTURE_TYPE_SUBPASS_END_INFO: VkStructureType = 1000109006;
pub const VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_END_INFO;
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;
pub const VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: VkStructureType = 1000376001;
pub const VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: VkStructureType = 1000369000;
pub const VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: VkStructureType = 1000270008;
pub const VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: VkStructureType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE;
pub const VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2: VkStructureType = 1000338002;
pub const VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT: VkStructureType = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2;
pub const VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2;
pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT;
pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT: VkStructureType = 1000090000;
pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR: VkStructureType = 1000119001;
pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: VkStructureType = 1000292001;
pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: VkStructureType = 1000479000;
pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR: VkStructureType = 1000480000;
pub const VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR: VkStructureType = 1000119002;
pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR;
pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR: VkStructureType = 1000274002;
pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR;
pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR: VkStructureType = 1000274000;
pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR;
pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR: VkStructureType = 1000274001;
pub const VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: VkStructureType = 1000239000;
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT: VkStructureType = 1000208009;
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: VkStructureType = 1000091003;
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000001000;
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: VkStructureType = 1000213001;
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV: VkStructureType = 1000505007;
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: VkStructureType = 1000292002;
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR;
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR: VkStructureType = 1000275001;
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR;
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR: VkStructureType = 1000275002;
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR;
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR: VkStructureType = 1000275003;
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR;
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR: VkStructureType = 1000275004;
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT: VkStructureType = 1000208002;
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT: VkStructureType = 1000208001;
pub const VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: VkStructureType = 1000460021;
pub const VK_STRUCTURE_TYPE_TENSOR_COPY_ARM: VkStructureType = 1000460012;
pub const VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM: VkStructureType = 1000460000;
pub const VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM: VkStructureType = 1000460013;
pub const VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM: VkStructureType = 1000460006;
pub const VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM: VkStructureType = 1000460005;
pub const VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM: VkStructureType = 1000460008;
pub const VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM: VkStructureType = 1000460007;
pub const VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: VkStructureType = 1000460022;
pub const VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM: VkStructureType = 1000460001;
pub const VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: VkStructureType = 1000041000;
pub const VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM: VkStructureType = 1000547003;
pub const VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM: VkStructureType = 1000547002;
pub const VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM: VkStructureType = 1000547004;
pub const VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM: VkStructureType = 1000484001;
pub const VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: VkStructureType = 1000207003;
pub const VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
pub const VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT: VkStructureType = 1000160000;
pub const VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: VkStructureType = 1000247000;
pub const VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: VkStructureType = 1000061000;
pub const VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: VkStructureType = 1000352002;
pub const VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: VkStructureType = 1000352001;
pub const VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR: VkStructureType = 1000023008;
pub const VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR: VkStructureType = 1000023001;
pub const VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR: VkStructureType = 1000023010;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: VkStructureType = 1000512000;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR: VkStructureType = 1000512005;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR: VkStructureType = 1000586003;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR: VkStructureType = 1000512001;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: VkStructureType = 1000512003;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000512004;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: VkStructureType = 1000024001;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: VkStructureType = 1000040000;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: VkStructureType = 1000040006;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR: VkStructureType = 1000586001;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: VkStructureType = 1000040001;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: VkStructureType = 1000040003;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: VkStructureType = 1000040005;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000040004;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: VkStructureType = 1000187000;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: VkStructureType = 1000187005;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR: VkStructureType = 1000586002;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: VkStructureType = 1000187004;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: VkStructureType = 1000187003;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: VkStructureType = 1000187002;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000187001;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR: VkStructureType = 1000024000;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: VkStructureType = 1000024002;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR: VkStructureType = 1000514001;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR: VkStructureType = 1000514002;
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: VkStructureType = 1000514003;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR: VkStructureType = 1000513000;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR: VkStructureType = 1000513003;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR: VkStructureType = 1000513010;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR: VkStructureType = 1000513002;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR: VkStructureType = 1000513005;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR: VkStructureType = 1000513008;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR: VkStructureType = 1000553007;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR: VkStructureType = 1000513006;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR: VkStructureType = 1000513007;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR: VkStructureType = 1000513009;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000513001;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: VkStructureType = 1000299003;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: VkStructureType = 1000038000;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: VkStructureType = 1000038004;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: VkStructureType = 1000038006;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR: VkStructureType = 1000038005;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: VkStructureType = 1000038003;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: VkStructureType = 1000038007;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: VkStructureType = 1000038011;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR: VkStructureType = 1000553003;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: VkStructureType = 1000038008;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: VkStructureType = 1000038009;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: VkStructureType = 1000038010;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: VkStructureType = 1000038002;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000038001;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: VkStructureType = 1000038013;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: VkStructureType = 1000038012;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: VkStructureType = 1000039000;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: VkStructureType = 1000039004;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: VkStructureType = 1000039006;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR: VkStructureType = 1000039005;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: VkStructureType = 1000039003;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: VkStructureType = 1000039007;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: VkStructureType = 1000039012;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR: VkStructureType = 1000553004;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: VkStructureType = 1000039009;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: VkStructureType = 1000039010;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: VkStructureType = 1000039011;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: VkStructureType = 1000039002;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000039001;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: VkStructureType = 1000039014;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: VkStructureType = 1000039013;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR: VkStructureType = 1000299000;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR: VkStructureType = 1000552000;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR: VkStructureType = 1000552002;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE: VkStructureType = 1000390002;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: VkStructureType = 1000299008;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR: VkStructureType = 1000299007;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: VkStructureType = 1000553000;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR: VkStructureType = 1000553002;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000553005;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: VkStructureType = 1000299001;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: VkStructureType = 1000299002;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE: VkStructureType = 1000390001;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR: VkStructureType = 1000552001;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: VkStructureType = 1000299010;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR: VkStructureType = 1000299009;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE: VkStructureType = 1000390003;
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: VkStructureType = 1000299004;
pub const VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR: VkStructureType = 1000023009;
pub const VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: VkStructureType = 1000553008;
pub const VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR: VkStructureType = 1000553006;
pub const VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR: VkStructureType = 1000023015;
pub const VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR: VkStructureType = 1000553001;
pub const VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: VkStructureType = 1000515001;
pub const VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR: VkStructureType = 1000023002;
pub const VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: VkStructureType = 1000023000;
pub const VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: VkStructureType = 1000023013;
pub const VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR: VkStructureType = 1000552003;
pub const VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR: VkStructureType = 1000023011;
pub const VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR: VkStructureType = 1000023005;
pub const VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR: VkStructureType = 1000023003;
pub const VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000023006;
pub const VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR: VkStructureType = 1000023007;
pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: VkStructureType = 35;
pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: VkStructureType = 1000150007;
pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: VkStructureType = 1000165007;
pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: VkStructureType = 1000138002;
pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: VkStructureType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV: VkStructureType = 1000570002;
pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM: VkStructureType = 1000460003;
pub const VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT: VkStructureType = 1000572008;
pub const VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT: VkStructureType = 1000572009;
pub const VK_SUBGROUP_FEATURE_ARITHMETIC_BIT: VkSubgroupFeatureFlagBits = 1 << 2;
pub const VK_SUBGROUP_FEATURE_BALLOT_BIT: VkSubgroupFeatureFlagBits = 1 << 3;
pub const VK_SUBGROUP_FEATURE_BASIC_BIT: VkSubgroupFeatureFlagBits = 1 << 0;
pub const VK_SUBGROUP_FEATURE_CLUSTERED_BIT: VkSubgroupFeatureFlagBits = 1 << 6;
pub const VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV: VkSubgroupFeatureFlagBits = 1 << 8;
pub const VK_SUBGROUP_FEATURE_QUAD_BIT: VkSubgroupFeatureFlagBits = 1 << 7;
pub const VK_SUBGROUP_FEATURE_ROTATE_BIT: VkSubgroupFeatureFlagBits = 1 << 9;
pub const VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR: VkSubgroupFeatureFlagBits = VK_SUBGROUP_FEATURE_ROTATE_BIT;
pub const VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT: VkSubgroupFeatureFlagBits = 1 << 10;
pub const VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR: VkSubgroupFeatureFlagBits = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT;
pub const VK_SUBGROUP_FEATURE_SHUFFLE_BIT: VkSubgroupFeatureFlagBits = 1 << 4;
pub const VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT: VkSubgroupFeatureFlagBits = 1 << 5;
pub const VK_SUBGROUP_FEATURE_VOTE_BIT: VkSubgroupFeatureFlagBits = 1 << 1;
pub const VK_SUBMIT_PROTECTED_BIT: VkSubmitFlagBits = 1 << 0;
pub const VK_SUBMIT_PROTECTED_BIT_KHR: VkSubmitFlagBits = VK_SUBMIT_PROTECTED_BIT;
pub const VK_SUBOPTIMAL_KHR: VkResult = 1000001003;
pub const VK_SUBPASS_CONTENTS_INLINE: VkSubpassContents = 0;
pub const VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT: VkSubpassContents = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR;
pub const VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR: VkSubpassContents = 1000451000;
pub const VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS: VkSubpassContents = 1;
pub const VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 3;
pub const VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 7;
pub const VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 2;
pub const VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM: VkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT;
pub const VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX: VkSubpassDescriptionFlagBits = 1 << 0;
pub const VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX: VkSubpassDescriptionFlagBits = 1 << 1;
pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM: VkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT;
pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 4;
pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM: VkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT;
pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 5;
pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM: VkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT;
pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 6;
pub const VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM: VkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT;
pub const VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM: VkSubpassDescriptionFlagBits = 1 << 8;
pub const VK_SUBPASS_EXTERNAL: u32 = !0;
pub const VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT: VkSubpassMergeStatusEXT = 1;
pub const VK_SUBPASS_MERGE_STATUS_MERGED_EXT: VkSubpassMergeStatusEXT = 0;
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT: VkSubpassMergeStatusEXT = 5;
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT: VkSubpassMergeStatusEXT = 6;
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT: VkSubpassMergeStatusEXT = 10;
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT: VkSubpassMergeStatusEXT = 7;
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT: VkSubpassMergeStatusEXT = 9;
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT: VkSubpassMergeStatusEXT = 11;
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT: VkSubpassMergeStatusEXT = 3;
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT: VkSubpassMergeStatusEXT = 2;
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT: VkSubpassMergeStatusEXT = 12;
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT: VkSubpassMergeStatusEXT = 8;
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT: VkSubpassMergeStatusEXT = 13;
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT: VkSubpassMergeStatusEXT = 4;
pub const VK_SUCCESS: VkResult = 0;
pub const VK_SURFACE_COUNTER_VBLANK_BIT_EXT: VkSurfaceCounterFlagBitsEXT = 1 << 0;
pub const VK_SURFACE_COUNTER_VBLANK_EXT: VkSurfaceCounterFlagBitsEXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT;
pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 4;
pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 6;
pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 7;
pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 5;
pub const VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 0;
pub const VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 8;
pub const VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 2;
pub const VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 3;
pub const VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 1;
pub const VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT: VkSwapchainCreateFlagBitsKHR = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR;
pub const VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 3;
pub const VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 2;
pub const VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 6;
pub const VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT: VkSwapchainCreateFlagBitsKHR = 1 << 9;
pub const VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 7;
pub const VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 1;
pub const VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 0;
pub const VK_SYSTEM_ALLOCATION_SCOPE_CACHE: VkSystemAllocationScope = 2;
pub const VK_SYSTEM_ALLOCATION_SCOPE_COMMAND: VkSystemAllocationScope = 0;
pub const VK_SYSTEM_ALLOCATION_SCOPE_DEVICE: VkSystemAllocationScope = 3;
pub const VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE: VkSystemAllocationScope = 4;
pub const VK_SYSTEM_ALLOCATION_SCOPE_OBJECT: VkSystemAllocationScope = 1;
pub const VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM: VkTensorCreateFlagBitsARM = 1 << 2;
pub const VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM: VkTensorCreateFlagBitsARM = 1 << 0;
pub const VK_TENSOR_CREATE_PROTECTED_BIT_ARM: VkTensorCreateFlagBitsARM = 1 << 1;
pub const VK_TENSOR_TILING_LINEAR_ARM: VkTensorTilingARM = 1;
pub const VK_TENSOR_TILING_OPTIMAL_ARM: VkTensorTilingARM = 0;
pub const VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM: VkTensorUsageFlagBitsARM = 1 << 5;
pub const VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM: VkTensorUsageFlagBitsARM = 1 << 4;
pub const VK_TENSOR_USAGE_SHADER_BIT_ARM: VkTensorUsageFlagBitsARM = 1 << 1;
pub const VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM: VkTensorUsageFlagBitsARM = 1 << 3;
pub const VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM: VkTensorUsageFlagBitsARM = 1 << 2;
pub const VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM: VkTensorViewCreateFlagBitsARM = 1 << 0;
pub const VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT: VkTessellationDomainOrigin = 1;
pub const VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR: VkTessellationDomainOrigin = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT;
pub const VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT: VkTessellationDomainOrigin = 0;
pub const VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR: VkTessellationDomainOrigin = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT;
pub const VK_THREAD_DONE_KHR: VkResult = 1000268001;
pub const VK_THREAD_IDLE_KHR: VkResult = 1000268000;
pub const VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM: VkTileShadingRenderPassFlagBitsQCOM = 1 << 0;
pub const VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM: VkTileShadingRenderPassFlagBitsQCOM = 1 << 1;
pub const VK_TIMEOUT: VkResult = 2;
pub const VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT: VkTimeDomainKHR = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR;
pub const VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR: VkTimeDomainKHR = 1;
pub const VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT: VkTimeDomainKHR = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR;
pub const VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR: VkTimeDomainKHR = 2;
pub const VK_TIME_DOMAIN_DEVICE_EXT: VkTimeDomainKHR = VK_TIME_DOMAIN_DEVICE_KHR;
pub const VK_TIME_DOMAIN_DEVICE_KHR: VkTimeDomainKHR = 0;
pub const VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT: VkTimeDomainKHR = 1000208000;
pub const VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT: VkTimeDomainKHR = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR;
pub const VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR: VkTimeDomainKHR = 3;
pub const VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT: VkTimeDomainKHR = 1000208001;
pub const VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT: VkToolPurposeFlagBits = 1 << 3;
pub const VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT: VkToolPurposeFlagBits = VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT;
pub const VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT: VkToolPurposeFlagBits = 1 << 6;
pub const VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT: VkToolPurposeFlagBits = 1 << 5;
pub const VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT: VkToolPurposeFlagBits = 1 << 4;
pub const VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT: VkToolPurposeFlagBits = VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT;
pub const VK_TOOL_PURPOSE_PROFILING_BIT: VkToolPurposeFlagBits = 1 << 1;
pub const VK_TOOL_PURPOSE_PROFILING_BIT_EXT: VkToolPurposeFlagBits = VK_TOOL_PURPOSE_PROFILING_BIT;
pub const VK_TOOL_PURPOSE_TRACING_BIT: VkToolPurposeFlagBits = 1 << 2;
pub const VK_TOOL_PURPOSE_TRACING_BIT_EXT: VkToolPurposeFlagBits = VK_TOOL_PURPOSE_TRACING_BIT;
pub const VK_TOOL_PURPOSE_VALIDATION_BIT: VkToolPurposeFlagBits = 1 << 0;
pub const VK_TOOL_PURPOSE_VALIDATION_BIT_EXT: VkToolPurposeFlagBits = VK_TOOL_PURPOSE_VALIDATION_BIT;
pub const VK_TRUE: u32 = 1;
pub const VK_USE_64_BIT_PTR_DEFINES: bool = true;
pub const VK_UUID_SIZE: u32 = 16;
pub const VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT: VkValidationCacheHeaderVersionEXT = 1;
pub const VK_VALIDATION_CHECK_ALL_EXT: VkValidationCheckEXT = 0;
pub const VK_VALIDATION_CHECK_SHADERS_EXT: VkValidationCheckEXT = 1;
pub const VK_VALIDATION_FEATURE_DISABLE_ALL_EXT: VkValidationFeatureDisableEXT = 0;
pub const VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT: VkValidationFeatureDisableEXT = 3;
pub const VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT: VkValidationFeatureDisableEXT = 5;
pub const VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT: VkValidationFeatureDisableEXT = 4;
pub const VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT: VkValidationFeatureDisableEXT = 1;
pub const VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT: VkValidationFeatureDisableEXT = 7;
pub const VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT: VkValidationFeatureDisableEXT = 2;
pub const VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT: VkValidationFeatureDisableEXT = 6;
pub const VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT: VkValidationFeatureEnableEXT = 2;
pub const VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT: VkValidationFeatureEnableEXT = 3;
pub const VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT: VkValidationFeatureEnableEXT = 0;
pub const VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT: VkValidationFeatureEnableEXT = 1;
pub const VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT: VkValidationFeatureEnableEXT = 4;
pub const VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME: &CStr = c"VK_VALVE_descriptor_set_host_mapping";
pub const VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION: u32 = 1;
pub const VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_EXTENSION_NAME: &CStr = c"VK_VALVE_fragment_density_map_layered";
pub const VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_SPEC_VERSION: u32 = 1;
pub const VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME: &CStr = c"VK_VALVE_mutable_descriptor_type";
pub const VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION: u32 = 1;
pub const VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME: &CStr = c"VK_VALVE_video_encode_rgb_conversion";
pub const VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_SPEC_VERSION: u32 = 1;
pub const VK_VENDOR_ID_CODEPLAY: VkVendorId = 0x10004;
pub const VK_VENDOR_ID_KAZAN: VkVendorId = 0x10003;
pub const VK_VENDOR_ID_KHRONOS: VkVendorId = 0x10000;
pub const VK_VENDOR_ID_MESA: VkVendorId = 0x10005;
pub const VK_VENDOR_ID_MOBILEYE: VkVendorId = 0x10007;
pub const VK_VENDOR_ID_POCL: VkVendorId = 0x10006;
pub const VK_VENDOR_ID_VIV: VkVendorId = 0x10001;
pub const VK_VENDOR_ID_VSI: VkVendorId = 0x10002;
pub const VK_VERTEX_INPUT_RATE_INSTANCE: VkVertexInputRate = 1;
pub const VK_VERTEX_INPUT_RATE_VERTEX: VkVertexInputRate = 0;
pub const VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR: VkVideoCapabilityFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR: VkVideoCapabilityFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: VkVideoChromaSubsamplingFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: VkVideoChromaSubsamplingFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: VkVideoChromaSubsamplingFlagBitsKHR = 1 << 3;
pub const VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR: VkVideoChromaSubsamplingFlagBitsKHR = 0;
pub const VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR: VkVideoChromaSubsamplingFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 3;
pub const VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 18;
pub const VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 16;
pub const VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 17;
pub const VK_VIDEO_CODEC_OPERATION_NONE_KHR: VkVideoCodecOperationFlagBitsKHR = 0;
pub const VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR: VkVideoCodingControlFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR: VkVideoCodingControlFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR: VkVideoCodingControlFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR: VkVideoComponentBitDepthFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR: VkVideoComponentBitDepthFlagBitsKHR = 1 << 4;
pub const VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR: VkVideoComponentBitDepthFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR: VkVideoComponentBitDepthFlagBitsKHR = 0;
pub const VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR: VkVideoDecodeCapabilityFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR: VkVideoDecodeCapabilityFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR: VkVideoDecodeH264PictureLayoutFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR: VkVideoDecodeH264PictureLayoutFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR: VkVideoDecodeH264PictureLayoutFlagBitsKHR = 0;
pub const VK_VIDEO_DECODE_USAGE_DEFAULT_KHR: VkVideoDecodeUsageFlagBitsKHR = 0;
pub const VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR: VkVideoDecodeUsageFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR: VkVideoDecodeUsageFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR: VkVideoDecodeUsageFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 5;
pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 3;
pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 4;
pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR: VkVideoEncodeAV1PredictionModeKHR = 3;
pub const VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR: VkVideoEncodeAV1PredictionModeKHR = 0;
pub const VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR: VkVideoEncodeAV1PredictionModeKHR = 1;
pub const VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR: VkVideoEncodeAV1PredictionModeKHR = 2;
pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR: VkVideoEncodeAV1RateControlGroupKHR = 2;
pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR: VkVideoEncodeAV1RateControlGroupKHR = 0;
pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR: VkVideoEncodeAV1RateControlGroupKHR = 1;
pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeAV1RateControlFlagBitsKHR = 1 << 3;
pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: VkVideoEncodeAV1RateControlFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR: VkVideoEncodeAV1RateControlFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeAV1RateControlFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR: VkVideoEncodeAV1StdFlagBitsKHR = 1 << 3;
pub const VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR: VkVideoEncodeAV1StdFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR: VkVideoEncodeAV1StdFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR: VkVideoEncodeAV1StdFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR: VkVideoEncodeAV1SuperblockSizeFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR: VkVideoEncodeAV1SuperblockSizeFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR: VkVideoEncodeCapabilityFlagBitsKHR = 1 << 3;
pub const VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR: VkVideoEncodeCapabilityFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR: VkVideoEncodeCapabilityFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR: VkVideoEncodeCapabilityFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR: VkVideoEncodeContentFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR: VkVideoEncodeContentFlagBitsKHR = 0;
pub const VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR: VkVideoEncodeContentFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR: VkVideoEncodeContentFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR: VkVideoEncodeFeedbackFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR: VkVideoEncodeFeedbackFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR: VkVideoEncodeFeedbackFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 4;
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 5;
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 10;
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 3;
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 8;
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 9;
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 6;
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 7;
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR: VkVideoEncodeH264RateControlFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeH264RateControlFlagBitsKHR = 1 << 3;
pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: VkVideoEncodeH264RateControlFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR: VkVideoEncodeH264RateControlFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeH264RateControlFlagBitsKHR = 1 << 4;
pub const VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 3;
pub const VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 14;
pub const VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 15;
pub const VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 16;
pub const VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 17;
pub const VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 20;
pub const VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 13;
pub const VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 10;
pub const VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 12;
pub const VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 11;
pub const VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 5;
pub const VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 4;
pub const VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 19;
pub const VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 9;
pub const VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 7;
pub const VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 8;
pub const VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 6;
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 4;
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 5;
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 11;
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 10;
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 3;
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 9;
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 8;
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 6;
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 7;
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR: VkVideoEncodeH265CtbSizeFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR: VkVideoEncodeH265CtbSizeFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR: VkVideoEncodeH265CtbSizeFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR: VkVideoEncodeH265RateControlFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeH265RateControlFlagBitsKHR = 1 << 3;
pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: VkVideoEncodeH265RateControlFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR: VkVideoEncodeH265RateControlFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeH265RateControlFlagBitsKHR = 1 << 4;
pub const VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 14;
pub const VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 16;
pub const VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 17;
pub const VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 18;
pub const VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 20;
pub const VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 15;
pub const VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 5;
pub const VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 8;
pub const VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 3;
pub const VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 12;
pub const VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 9;
pub const VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 19;
pub const VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 4;
pub const VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 10;
pub const VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 11;
pub const VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 13;
pub const VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 7;
pub const VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 6;
pub const VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR: VkVideoEncodeH265TransformBlockSizeFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR: VkVideoEncodeH265TransformBlockSizeFlagBitsKHR = 1 << 3;
pub const VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR: VkVideoEncodeH265TransformBlockSizeFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR: VkVideoEncodeH265TransformBlockSizeFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR: VkVideoEncodeFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR: VkVideoEncodeIntraRefreshModeFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR: VkVideoEncodeIntraRefreshModeFlagBitsKHR = 1 << 3;
pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR: VkVideoEncodeIntraRefreshModeFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR: VkVideoEncodeIntraRefreshModeFlagBitsKHR = 0;
pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR: VkVideoEncodeIntraRefreshModeFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR: VkVideoEncodeRateControlModeFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR: VkVideoEncodeRateControlModeFlagBitsKHR = 0;
pub const VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR: VkVideoEncodeRateControlModeFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR: VkVideoEncodeRateControlModeFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE: VkVideoEncodeRgbChromaOffsetFlagBitsVALVE = 1 << 0;
pub const VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE: VkVideoEncodeRgbChromaOffsetFlagBitsVALVE = 1 << 1;
pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagBitsVALVE = 1 << 0;
pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagBitsVALVE = 1 << 4;
pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagBitsVALVE = 1 << 3;
pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagBitsVALVE = 1 << 2;
pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagBitsVALVE = 1 << 1;
pub const VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE: VkVideoEncodeRgbRangeCompressionFlagBitsVALVE = 1 << 0;
pub const VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE: VkVideoEncodeRgbRangeCompressionFlagBitsVALVE = 1 << 1;
pub const VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR: VkVideoEncodeTuningModeKHR = 0;
pub const VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR: VkVideoEncodeTuningModeKHR = 1;
pub const VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR: VkVideoEncodeTuningModeKHR = 4;
pub const VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR: VkVideoEncodeTuningModeKHR = 2;
pub const VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR: VkVideoEncodeTuningModeKHR = 3;
pub const VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR: VkVideoEncodeUsageFlagBitsKHR = 1 << 3;
pub const VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR: VkVideoEncodeUsageFlagBitsKHR = 0;
pub const VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR: VkVideoEncodeUsageFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR: VkVideoEncodeUsageFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR: VkVideoEncodeUsageFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR: VkVideoEncodeFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR: VkVideoEncodeFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 4;
pub const VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 1;
pub const VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 3;
pub const VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 2;
pub const VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 5;
pub const VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 0;
pub const VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR: VkVideoSessionParametersCreateFlagBitsKHR = 1 << 0;
pub const VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV: VkViewportCoordinateSwizzleNV = 7;
pub const VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV: VkViewportCoordinateSwizzleNV = 1;
pub const VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV: VkViewportCoordinateSwizzleNV = 3;
pub const VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV: VkViewportCoordinateSwizzleNV = 5;
pub const VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV: VkViewportCoordinateSwizzleNV = 6;
pub const VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV: VkViewportCoordinateSwizzleNV = 0;
pub const VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV: VkViewportCoordinateSwizzleNV = 2;
pub const VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV: VkViewportCoordinateSwizzleNV = 4;
pub const VK_WHOLE_SIZE: u64 = !0;

pub const fn VK_API_VERSION_MAJOR(version: u32) -> u32 {
    (version >> 22) & 0x7F
}

pub const fn VK_API_VERSION_MINOR(version: u32) -> u32 {
    (version >> 12) & 0x3FF
}

pub const fn VK_API_VERSION_PATCH(version: u32) -> u32 {
    version & 0xFFF
}

pub const fn VK_API_VERSION_VARIANT(version: u32) -> u32 {
    version >> 29
}

pub const fn VK_MAKE_API_VERSION(variant: u32, major: u32, minor: u32, patch: u32) -> u32 {
    (variant << 29) | (major << 22) | (minor << 12) | patch
}

pub const fn VK_MAKE_VERSION(major: u32, minor: u32, patch: u32) -> u32 {
    (major << 22) | (minor << 12) | patch
}

pub const fn VK_VERSION_MAJOR(version: u32) -> u32 {
    version >> 22
}

pub const fn VK_VERSION_MINOR(version: u32) -> u32 {
    (version >> 12) & 0x3FF
}

pub const fn VK_VERSION_PATCH(version: u32) -> u32 {
    version & 0xFFF
}

unsafe extern "system" {
    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkAcquireDrmDisplayEXT(physicalDevice: VkPhysicalDevice, drmFd: i32, display: VkDisplayKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkAcquireNextImage2KHR(device: VkDevice, pAcquireInfo: *const VkAcquireNextImageInfoKHR, pImageIndex: *mut u32) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkAcquireNextImageKHR(device: VkDevice, swapchain: VkSwapchainKHR, timeout: u64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: *mut u32) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkAcquirePerformanceConfigurationINTEL(device: VkDevice, pAcquireInfo: *const VkPerformanceConfigurationAcquireInfoINTEL, pConfiguration: *mut VkPerformanceConfigurationINTEL) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkAcquireProfilingLockKHR(device: VkDevice, pInfo: *const VkAcquireProfilingLockInfoKHR) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkAllocateCommandBuffers(device: VkDevice, pAllocateInfo: *const VkCommandBufferAllocateInfo, pCommandBuffers: *mut VkCommandBuffer) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkAllocateDescriptorSets(device: VkDevice, pAllocateInfo: *const VkDescriptorSetAllocateInfo, pDescriptorSets: *mut VkDescriptorSet) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkAllocateMemory(device: VkDevice, pAllocateInfo: *const VkMemoryAllocateInfo, pAllocator: *const VkAllocationCallbacks, pMemory: *mut VkDeviceMemory) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkAntiLagUpdateAMD(device: VkDevice, pData: *const VkAntiLagDataAMD);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkBeginCommandBuffer(commandBuffer: VkCommandBuffer, pBeginInfo: *const VkCommandBufferBeginInfo) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkBindAccelerationStructureMemoryNV(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindAccelerationStructureMemoryInfoNV) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkBindBufferMemory(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkBindBufferMemory2(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindBufferMemoryInfo) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkBindBufferMemory2KHR(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindBufferMemoryInfo) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkBindDataGraphPipelineSessionMemoryARM(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindDataGraphPipelineSessionMemoryInfoARM) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkBindImageMemory(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkBindImageMemory2(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindImageMemoryInfo) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkBindImageMemory2KHR(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindImageMemoryInfo) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkBindOpticalFlowSessionImageNV(device: VkDevice, session: VkOpticalFlowSessionNV, bindingPoint: VkOpticalFlowSessionBindingPointNV, view: VkImageView, layout: VkImageLayout) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkBindTensorMemoryARM(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindTensorMemoryInfoARM) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkBindVideoSessionMemoryKHR(device: VkDevice, videoSession: VkVideoSessionKHR, bindSessionMemoryInfoCount: u32, pBindSessionMemoryInfos: *const VkBindVideoSessionMemoryInfoKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkBuildAccelerationStructuresKHR(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: *const *const VkAccelerationStructureBuildRangeInfoKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkBuildMicromapsEXT(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: u32, pInfos: *const VkMicromapBuildInfoEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBeginConditionalRenderingEXT(commandBuffer: VkCommandBuffer, pConditionalRenderingBegin: *const VkConditionalRenderingBeginInfoEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBeginCustomResolveEXT(commandBuffer: VkCommandBuffer, pBeginCustomResolveInfo: *const VkBeginCustomResolveInfoEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBeginDebugUtilsLabelEXT(commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBeginPerTileExecutionQCOM(commandBuffer: VkCommandBuffer, pPerTileBeginInfo: *const VkPerTileBeginInfoQCOM);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdBeginQuery(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, flags: VkQueryControlFlags);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBeginQueryIndexedEXT(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, flags: VkQueryControlFlags, index: u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdBeginRenderPass(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, contents: VkSubpassContents);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdBeginRenderPass2(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, pSubpassBeginInfo: *const VkSubpassBeginInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBeginRenderPass2KHR(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, pSubpassBeginInfo: *const VkSubpassBeginInfo);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdBeginRendering(commandBuffer: VkCommandBuffer, pRenderingInfo: *const VkRenderingInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBeginRenderingKHR(commandBuffer: VkCommandBuffer, pRenderingInfo: *const VkRenderingInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBeginTransformFeedbackEXT(commandBuffer: VkCommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: *const VkBuffer, pCounterBufferOffsets: *const VkDeviceSize);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBeginVideoCodingKHR(commandBuffer: VkCommandBuffer, pBeginInfo: *const VkVideoBeginCodingInfoKHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer: VkCommandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo: *const VkBindDescriptorBufferEmbeddedSamplersInfoEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBindDescriptorBufferEmbeddedSamplersEXT(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBindDescriptorBuffersEXT(commandBuffer: VkCommandBuffer, bufferCount: u32, pBindingInfos: *const VkDescriptorBufferBindingInfoEXT);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdBindDescriptorSets(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: u32, descriptorSetCount: u32, pDescriptorSets: *const VkDescriptorSet, dynamicOffsetCount: u32, pDynamicOffsets: *const u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdBindDescriptorSets2(commandBuffer: VkCommandBuffer, pBindDescriptorSetsInfo: *const VkBindDescriptorSetsInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBindDescriptorSets2KHR(commandBuffer: VkCommandBuffer, pBindDescriptorSetsInfo: *const VkBindDescriptorSetsInfo);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdBindIndexBuffer(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdBindIndexBuffer2(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize, indexType: VkIndexType);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBindIndexBuffer2KHR(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize, indexType: VkIndexType);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBindInvocationMaskHUAWEI(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdBindPipeline(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBindPipelineShaderGroupNV(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, groupIndex: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBindShadersEXT(commandBuffer: VkCommandBuffer, stageCount: u32, pStages: *const VkShaderStageFlagBits, pShaders: *const VkShaderEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBindShadingRateImageNV(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBindTileMemoryQCOM(commandBuffer: VkCommandBuffer, pTileMemoryBindInfo: *const VkTileMemoryBindInfoQCOM);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBindTransformFeedbackBuffersEXT(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdBindVertexBuffers(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdBindVertexBuffers2(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize, pStrides: *const VkDeviceSize);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBindVertexBuffers2EXT(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize, pStrides: *const VkDeviceSize);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdBlitImage(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageBlit, filter: VkFilter);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdBlitImage2(commandBuffer: VkCommandBuffer, pBlitImageInfo: *const VkBlitImageInfo2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBlitImage2KHR(commandBuffer: VkCommandBuffer, pBlitImageInfo: *const VkBlitImageInfo2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBuildAccelerationStructureNV(commandBuffer: VkCommandBuffer, pInfo: *const VkAccelerationStructureInfoNV, instanceData: VkBuffer, instanceOffset: VkDeviceSize, update: VkBool32, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, scratch: VkBuffer, scratchOffset: VkDeviceSize);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, pIndirectDeviceAddresses: *const VkDeviceAddress, pIndirectStrides: *const u32, ppMaxPrimitiveCounts: *const *const u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBuildAccelerationStructuresKHR(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: *const *const VkAccelerationStructureBuildRangeInfoKHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBuildClusterAccelerationStructureIndirectNV(commandBuffer: VkCommandBuffer, pCommandInfos: *const VkClusterAccelerationStructureCommandsInfoNV);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBuildMicromapsEXT(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkMicromapBuildInfoEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdBuildPartitionedAccelerationStructuresNV(commandBuffer: VkCommandBuffer, pBuildInfo: *const VkBuildPartitionedAccelerationStructureInfoNV);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdClearAttachments(commandBuffer: VkCommandBuffer, attachmentCount: u32, pAttachments: *const VkClearAttachment, rectCount: u32, pRects: *const VkClearRect);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdClearColorImage(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: *const VkClearColorValue, rangeCount: u32, pRanges: *const VkImageSubresourceRange);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdClearDepthStencilImage(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: *const VkClearDepthStencilValue, rangeCount: u32, pRanges: *const VkImageSubresourceRange);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdControlVideoCodingKHR(commandBuffer: VkCommandBuffer, pCodingControlInfo: *const VkVideoCodingControlInfoKHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdConvertCooperativeVectorMatrixNV(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkConvertCooperativeVectorMatrixInfoNV);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCopyAccelerationStructureKHR(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyAccelerationStructureInfoKHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCopyAccelerationStructureNV(commandBuffer: VkCommandBuffer, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, mode: VkCopyAccelerationStructureModeKHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdCopyBuffer(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferCopy);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdCopyBuffer2(commandBuffer: VkCommandBuffer, pCopyBufferInfo: *const VkCopyBufferInfo2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCopyBuffer2KHR(commandBuffer: VkCommandBuffer, pCopyBufferInfo: *const VkCopyBufferInfo2);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdCopyBufferToImage(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkBufferImageCopy);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdCopyBufferToImage2(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: *const VkCopyBufferToImageInfo2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCopyBufferToImage2KHR(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: *const VkCopyBufferToImageInfo2);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdCopyImage(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageCopy);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdCopyImage2(commandBuffer: VkCommandBuffer, pCopyImageInfo: *const VkCopyImageInfo2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCopyImage2KHR(commandBuffer: VkCommandBuffer, pCopyImageInfo: *const VkCopyImageInfo2);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdCopyImageToBuffer(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferImageCopy);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdCopyImageToBuffer2(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: *const VkCopyImageToBufferInfo2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCopyImageToBuffer2KHR(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: *const VkCopyImageToBufferInfo2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCopyMemoryIndirectKHR(commandBuffer: VkCommandBuffer, pCopyMemoryIndirectInfo: *const VkCopyMemoryIndirectInfoKHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCopyMemoryIndirectNV(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: u32, stride: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCopyMemoryToImageIndirectKHR(commandBuffer: VkCommandBuffer, pCopyMemoryToImageIndirectInfo: *const VkCopyMemoryToImageIndirectInfoKHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCopyMemoryToImageIndirectNV(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: u32, stride: u32, dstImage: VkImage, dstImageLayout: VkImageLayout, pImageSubresources: *const VkImageSubresourceLayers);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCopyMemoryToMicromapEXT(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMemoryToMicromapInfoEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCopyMicromapEXT(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMicromapInfoEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCopyMicromapToMemoryEXT(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMicromapToMemoryInfoEXT);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdCopyQueryPoolResults(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCopyTensorARM(commandBuffer: VkCommandBuffer, pCopyTensorInfo: *const VkCopyTensorInfoARM);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdCuLaunchKernelNVX(commandBuffer: VkCommandBuffer, pLaunchInfo: *const VkCuLaunchInfoNVX);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDebugMarkerBeginEXT(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDebugMarkerEndEXT(commandBuffer: VkCommandBuffer);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDebugMarkerInsertEXT(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDecodeVideoKHR(commandBuffer: VkCommandBuffer, pDecodeInfo: *const VkVideoDecodeInfoKHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDecompressMemoryEXT(commandBuffer: VkCommandBuffer, pDecompressMemoryInfoEXT: *const VkDecompressMemoryInfoEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDecompressMemoryIndirectCountEXT(commandBuffer: VkCommandBuffer, decompressionMethod: VkMemoryDecompressionMethodFlagsEXT, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, maxDecompressionCount: u32, stride: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDecompressMemoryIndirectCountNV(commandBuffer: VkCommandBuffer, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, stride: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDecompressMemoryNV(commandBuffer: VkCommandBuffer, decompressRegionCount: u32, pDecompressMemoryRegions: *const VkDecompressMemoryRegionNV);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdDispatch(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdDispatchBase(commandBuffer: VkCommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDispatchBaseKHR(commandBuffer: VkCommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDispatchDataGraphARM(commandBuffer: VkCommandBuffer, session: VkDataGraphPipelineSessionARM, pInfo: *const VkDataGraphPipelineDispatchInfoARM);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdDispatchIndirect(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDispatchTileQCOM(commandBuffer: VkCommandBuffer, pDispatchTileInfo: *const VkDispatchTileInfoQCOM);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdDraw(commandBuffer: VkCommandBuffer, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDrawClusterHUAWEI(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDrawClusterIndirectHUAWEI(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdDrawIndexed(commandBuffer: VkCommandBuffer, indexCount: u32, instanceCount: u32, firstIndex: u32, vertexOffset: i32, firstInstance: u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdDrawIndexedIndirect(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdDrawIndexedIndirectCount(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDrawIndexedIndirectCountAMD(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDrawIndexedIndirectCountKHR(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdDrawIndirect(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDrawIndirectByteCountEXT(commandBuffer: VkCommandBuffer, instanceCount: u32, firstInstance: u32, counterBuffer: VkBuffer, counterBufferOffset: VkDeviceSize, counterOffset: u32, vertexStride: u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdDrawIndirectCount(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDrawIndirectCountAMD(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDrawIndirectCountKHR(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDrawMeshTasksEXT(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDrawMeshTasksIndirectCountEXT(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDrawMeshTasksIndirectCountNV(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDrawMeshTasksIndirectEXT(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDrawMeshTasksIndirectNV(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDrawMeshTasksNV(commandBuffer: VkCommandBuffer, taskCount: u32, firstTask: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDrawMultiEXT(commandBuffer: VkCommandBuffer, drawCount: u32, pVertexInfo: *const VkMultiDrawInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdDrawMultiIndexedEXT(commandBuffer: VkCommandBuffer, drawCount: u32, pIndexInfo: *const VkMultiDrawIndexedInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32, pVertexOffset: *const i32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdEncodeVideoKHR(commandBuffer: VkCommandBuffer, pEncodeInfo: *const VkVideoEncodeInfoKHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdEndConditionalRenderingEXT(commandBuffer: VkCommandBuffer);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdEndDebugUtilsLabelEXT(commandBuffer: VkCommandBuffer);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdEndPerTileExecutionQCOM(commandBuffer: VkCommandBuffer, pPerTileEndInfo: *const VkPerTileEndInfoQCOM);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdEndQuery(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdEndQueryIndexedEXT(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, index: u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdEndRenderPass(commandBuffer: VkCommandBuffer);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdEndRenderPass2(commandBuffer: VkCommandBuffer, pSubpassEndInfo: *const VkSubpassEndInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdEndRenderPass2KHR(commandBuffer: VkCommandBuffer, pSubpassEndInfo: *const VkSubpassEndInfo);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdEndRendering(commandBuffer: VkCommandBuffer);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdEndRendering2EXT(commandBuffer: VkCommandBuffer, pRenderingEndInfo: *const VkRenderingEndInfoKHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdEndRendering2KHR(commandBuffer: VkCommandBuffer, pRenderingEndInfo: *const VkRenderingEndInfoKHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdEndRenderingKHR(commandBuffer: VkCommandBuffer);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdEndTransformFeedbackEXT(commandBuffer: VkCommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: *const VkBuffer, pCounterBufferOffsets: *const VkDeviceSize);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdEndVideoCodingKHR(commandBuffer: VkCommandBuffer, pEndCodingInfo: *const VkVideoEndCodingInfoKHR);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdExecuteCommands(commandBuffer: VkCommandBuffer, commandBufferCount: u32, pCommandBuffers: *const VkCommandBuffer);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdExecuteGeneratedCommandsEXT(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdExecuteGeneratedCommandsNV(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdFillBuffer(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdInsertDebugUtilsLabelEXT(commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdNextSubpass(commandBuffer: VkCommandBuffer, contents: VkSubpassContents);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdNextSubpass2(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: *const VkSubpassBeginInfo, pSubpassEndInfo: *const VkSubpassEndInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdNextSubpass2KHR(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: *const VkSubpassBeginInfo, pSubpassEndInfo: *const VkSubpassEndInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdOpticalFlowExecuteNV(commandBuffer: VkCommandBuffer, session: VkOpticalFlowSessionNV, pExecuteInfo: *const VkOpticalFlowExecuteInfoNV);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdPipelineBarrier(commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: u32, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: *const VkImageMemoryBarrier);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdPipelineBarrier2(commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdPipelineBarrier2KHR(commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdPreprocessGeneratedCommandsEXT(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoEXT, stateCommandBuffer: VkCommandBuffer);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdPreprocessGeneratedCommandsNV(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdPushConstants(commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: u32, size: u32, pValues: *const c_void);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdPushConstants2(commandBuffer: VkCommandBuffer, pPushConstantsInfo: *const VkPushConstantsInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdPushConstants2KHR(commandBuffer: VkCommandBuffer, pPushConstantsInfo: *const VkPushConstantsInfo);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdPushDescriptorSet(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdPushDescriptorSet2(commandBuffer: VkCommandBuffer, pPushDescriptorSetInfo: *const VkPushDescriptorSetInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdPushDescriptorSet2KHR(commandBuffer: VkCommandBuffer, pPushDescriptorSetInfo: *const VkPushDescriptorSetInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdPushDescriptorSetKHR(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdPushDescriptorSetWithTemplate(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: u32, pData: *const c_void);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdPushDescriptorSetWithTemplate2(commandBuffer: VkCommandBuffer, pPushDescriptorSetWithTemplateInfo: *const VkPushDescriptorSetWithTemplateInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdPushDescriptorSetWithTemplate2KHR(commandBuffer: VkCommandBuffer, pPushDescriptorSetWithTemplateInfo: *const VkPushDescriptorSetWithTemplateInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: u32, pData: *const c_void);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdResetEvent(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdResetEvent2(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdResetEvent2KHR(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdResetQueryPool(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdResolveImage(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageResolve);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdResolveImage2(commandBuffer: VkCommandBuffer, pResolveImageInfo: *const VkResolveImageInfo2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdResolveImage2KHR(commandBuffer: VkCommandBuffer, pResolveImageInfo: *const VkResolveImageInfo2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetAlphaToCoverageEnableEXT(commandBuffer: VkCommandBuffer, alphaToCoverageEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetAlphaToOneEnableEXT(commandBuffer: VkCommandBuffer, alphaToOneEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetAttachmentFeedbackLoopEnableEXT(commandBuffer: VkCommandBuffer, aspectMask: VkImageAspectFlags);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetBlendConstants(commandBuffer: VkCommandBuffer, blendConstants: *const f32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetCheckpointNV(commandBuffer: VkCommandBuffer, pCheckpointMarker: *const c_void);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetCoarseSampleOrderNV(commandBuffer: VkCommandBuffer, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: u32, pCustomSampleOrders: *const VkCoarseSampleOrderCustomNV);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetColorBlendAdvancedEXT(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendAdvanced: *const VkColorBlendAdvancedEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetColorBlendEnableEXT(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendEnables: *const VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetColorBlendEquationEXT(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendEquations: *const VkColorBlendEquationEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetColorWriteEnableEXT(commandBuffer: VkCommandBuffer, attachmentCount: u32, pColorWriteEnables: *const VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetColorWriteMaskEXT(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorWriteMasks: *const VkColorComponentFlags);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetComputeOccupancyPriorityNV(commandBuffer: VkCommandBuffer, pParameters: *const VkComputeOccupancyPriorityParametersNV);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetConservativeRasterizationModeEXT(commandBuffer: VkCommandBuffer, conservativeRasterizationMode: VkConservativeRasterizationModeEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetCoverageModulationModeNV(commandBuffer: VkCommandBuffer, coverageModulationMode: VkCoverageModulationModeNV);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetCoverageModulationTableEnableNV(commandBuffer: VkCommandBuffer, coverageModulationTableEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetCoverageModulationTableNV(commandBuffer: VkCommandBuffer, coverageModulationTableCount: u32, pCoverageModulationTable: *const f32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetCoverageReductionModeNV(commandBuffer: VkCommandBuffer, coverageReductionMode: VkCoverageReductionModeNV);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetCoverageToColorEnableNV(commandBuffer: VkCommandBuffer, coverageToColorEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetCoverageToColorLocationNV(commandBuffer: VkCommandBuffer, coverageToColorLocation: u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetCullMode(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetCullModeEXT(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetDepthBias(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: f32, depthBiasClamp: f32, depthBiasSlopeFactor: f32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetDepthBias2EXT(commandBuffer: VkCommandBuffer, pDepthBiasInfo: *const VkDepthBiasInfoEXT);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetDepthBiasEnable(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetDepthBiasEnableEXT(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetDepthBounds(commandBuffer: VkCommandBuffer, minDepthBounds: f32, maxDepthBounds: f32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetDepthBoundsTestEnable(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetDepthBoundsTestEnableEXT(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetDepthClampEnableEXT(commandBuffer: VkCommandBuffer, depthClampEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetDepthClampRangeEXT(commandBuffer: VkCommandBuffer, depthClampMode: VkDepthClampModeEXT, pDepthClampRange: *const VkDepthClampRangeEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetDepthClipEnableEXT(commandBuffer: VkCommandBuffer, depthClipEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetDepthClipNegativeOneToOneEXT(commandBuffer: VkCommandBuffer, negativeOneToOne: VkBool32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetDepthCompareOp(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetDepthCompareOpEXT(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetDepthTestEnable(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetDepthTestEnableEXT(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetDepthWriteEnable(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetDepthWriteEnableEXT(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetDescriptorBufferOffsets2EXT(commandBuffer: VkCommandBuffer, pSetDescriptorBufferOffsetsInfo: *const VkSetDescriptorBufferOffsetsInfoEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetDescriptorBufferOffsetsEXT(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: u32, setCount: u32, pBufferIndices: *const u32, pOffsets: *const VkDeviceSize);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetDeviceMask(commandBuffer: VkCommandBuffer, deviceMask: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetDeviceMaskKHR(commandBuffer: VkCommandBuffer, deviceMask: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetDiscardRectangleEXT(commandBuffer: VkCommandBuffer, firstDiscardRectangle: u32, discardRectangleCount: u32, pDiscardRectangles: *const VkRect2D);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetDiscardRectangleEnableEXT(commandBuffer: VkCommandBuffer, discardRectangleEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetDiscardRectangleModeEXT(commandBuffer: VkCommandBuffer, discardRectangleMode: VkDiscardRectangleModeEXT);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetEvent(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetEvent2(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetEvent2KHR(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetExclusiveScissorEnableNV(commandBuffer: VkCommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissorEnables: *const VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetExclusiveScissorNV(commandBuffer: VkCommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissors: *const VkRect2D);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetExtraPrimitiveOverestimationSizeEXT(commandBuffer: VkCommandBuffer, extraPrimitiveOverestimationSize: f32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetFragmentShadingRateEnumNV(commandBuffer: VkCommandBuffer, shadingRate: VkFragmentShadingRateNV, combinerOps: *const VkFragmentShadingRateCombinerOpKHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetFragmentShadingRateKHR(commandBuffer: VkCommandBuffer, pFragmentSize: *const VkExtent2D, combinerOps: *const VkFragmentShadingRateCombinerOpKHR);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetFrontFace(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetFrontFaceEXT(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetLineRasterizationModeEXT(commandBuffer: VkCommandBuffer, lineRasterizationMode: VkLineRasterizationModeEXT);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetLineStipple(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetLineStippleEXT(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetLineStippleEnableEXT(commandBuffer: VkCommandBuffer, stippledLineEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetLineStippleKHR(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetLineWidth(commandBuffer: VkCommandBuffer, lineWidth: f32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetLogicOpEXT(commandBuffer: VkCommandBuffer, logicOp: VkLogicOp);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetLogicOpEnableEXT(commandBuffer: VkCommandBuffer, logicOpEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetPatchControlPointsEXT(commandBuffer: VkCommandBuffer, patchControlPoints: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetPerformanceMarkerINTEL(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkPerformanceMarkerInfoINTEL) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetPerformanceOverrideINTEL(commandBuffer: VkCommandBuffer, pOverrideInfo: *const VkPerformanceOverrideInfoINTEL) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkPerformanceStreamMarkerInfoINTEL) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetPolygonModeEXT(commandBuffer: VkCommandBuffer, polygonMode: VkPolygonMode);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetPrimitiveRestartEnable(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetPrimitiveRestartEnableEXT(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetPrimitiveTopology(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetPrimitiveTopologyEXT(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetProvokingVertexModeEXT(commandBuffer: VkCommandBuffer, provokingVertexMode: VkProvokingVertexModeEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetRasterizationSamplesEXT(commandBuffer: VkCommandBuffer, rasterizationSamples: VkSampleCountFlagBits);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetRasterizationStreamEXT(commandBuffer: VkCommandBuffer, rasterizationStream: u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetRasterizerDiscardEnable(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetRasterizerDiscardEnableEXT(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer: VkCommandBuffer, pipelineStackSize: u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetRenderingAttachmentLocations(commandBuffer: VkCommandBuffer, pLocationInfo: *const VkRenderingAttachmentLocationInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetRenderingAttachmentLocationsKHR(commandBuffer: VkCommandBuffer, pLocationInfo: *const VkRenderingAttachmentLocationInfo);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetRenderingInputAttachmentIndices(commandBuffer: VkCommandBuffer, pInputAttachmentIndexInfo: *const VkRenderingInputAttachmentIndexInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetRenderingInputAttachmentIndicesKHR(commandBuffer: VkCommandBuffer, pInputAttachmentIndexInfo: *const VkRenderingInputAttachmentIndexInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetRepresentativeFragmentTestEnableNV(commandBuffer: VkCommandBuffer, representativeFragmentTestEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetSampleLocationsEXT(commandBuffer: VkCommandBuffer, pSampleLocationsInfo: *const VkSampleLocationsInfoEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetSampleLocationsEnableEXT(commandBuffer: VkCommandBuffer, sampleLocationsEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetSampleMaskEXT(commandBuffer: VkCommandBuffer, samples: VkSampleCountFlagBits, pSampleMask: *const VkSampleMask);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetScissor(commandBuffer: VkCommandBuffer, firstScissor: u32, scissorCount: u32, pScissors: *const VkRect2D);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetScissorWithCount(commandBuffer: VkCommandBuffer, scissorCount: u32, pScissors: *const VkRect2D);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetScissorWithCountEXT(commandBuffer: VkCommandBuffer, scissorCount: u32, pScissors: *const VkRect2D);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetShadingRateImageEnableNV(commandBuffer: VkCommandBuffer, shadingRateImageEnable: VkBool32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetStencilCompareMask(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetStencilOp(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetStencilOpEXT(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetStencilReference(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetStencilTestEnable(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetStencilTestEnableEXT(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetStencilWriteMask(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetTessellationDomainOriginEXT(commandBuffer: VkCommandBuffer, domainOrigin: VkTessellationDomainOrigin);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetVertexInputEXT(commandBuffer: VkCommandBuffer, vertexBindingDescriptionCount: u32, pVertexBindingDescriptions: *const VkVertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: u32, pVertexAttributeDescriptions: *const VkVertexInputAttributeDescription2EXT);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetViewport(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewports: *const VkViewport);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetViewportShadingRatePaletteNV(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pShadingRatePalettes: *const VkShadingRatePaletteNV);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetViewportSwizzleNV(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewportSwizzles: *const VkViewportSwizzleNV);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetViewportWScalingEnableNV(commandBuffer: VkCommandBuffer, viewportWScalingEnable: VkBool32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetViewportWScalingNV(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewportWScalings: *const VkViewportWScalingNV);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdSetViewportWithCount(commandBuffer: VkCommandBuffer, viewportCount: u32, pViewports: *const VkViewport);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSetViewportWithCountEXT(commandBuffer: VkCommandBuffer, viewportCount: u32, pViewports: *const VkViewport);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdSubpassShadingHUAWEI(commandBuffer: VkCommandBuffer);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdTraceRaysIndirect2KHR(commandBuffer: VkCommandBuffer, indirectDeviceAddress: VkDeviceAddress);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdTraceRaysIndirectKHR(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, indirectDeviceAddress: VkDeviceAddress);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdTraceRaysKHR(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, width: u32, height: u32, depth: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdTraceRaysNV(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: u32, height: u32, depth: u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdUpdateBuffer(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: *const c_void);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdUpdatePipelineIndirectBufferNV(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdWaitEvents(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, memoryBarrierCount: u32, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: *const VkImageMemoryBarrier);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdWaitEvents2(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdWaitEvents2KHR(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfo);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer: VkCommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureKHR, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer: VkCommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureNV, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdWriteBufferMarker2AMD(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdWriteBufferMarkerAMD(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdWriteMicromapsPropertiesEXT(commandBuffer: VkCommandBuffer, micromapCount: u32, pMicromaps: *const VkMicromapEXT, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdWriteTimestamp(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, queryPool: VkQueryPool, query: u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCmdWriteTimestamp2(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCmdWriteTimestamp2KHR(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCompileDeferredNV(device: VkDevice, pipeline: VkPipeline, shader: u32) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkConvertCooperativeVectorMatrixNV(device: VkDevice, pInfo: *const VkConvertCooperativeVectorMatrixInfoNV) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCopyAccelerationStructureKHR(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyAccelerationStructureInfoKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCopyAccelerationStructureToMemoryKHR(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCopyImageToImage(device: VkDevice, pCopyImageToImageInfo: *const VkCopyImageToImageInfo) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCopyImageToImageEXT(device: VkDevice, pCopyImageToImageInfo: *const VkCopyImageToImageInfo) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCopyImageToMemory(device: VkDevice, pCopyImageToMemoryInfo: *const VkCopyImageToMemoryInfo) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCopyImageToMemoryEXT(device: VkDevice, pCopyImageToMemoryInfo: *const VkCopyImageToMemoryInfo) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCopyMemoryToAccelerationStructureKHR(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCopyMemoryToImage(device: VkDevice, pCopyMemoryToImageInfo: *const VkCopyMemoryToImageInfo) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCopyMemoryToImageEXT(device: VkDevice, pCopyMemoryToImageInfo: *const VkCopyMemoryToImageInfo) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCopyMemoryToMicromapEXT(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMemoryToMicromapInfoEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCopyMicromapEXT(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMicromapInfoEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCopyMicromapToMemoryEXT(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMicromapToMemoryInfoEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateAccelerationStructureKHR(device: VkDevice, pCreateInfo: *const VkAccelerationStructureCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pAccelerationStructure: *mut VkAccelerationStructureKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateAccelerationStructureNV(device: VkDevice, pCreateInfo: *const VkAccelerationStructureCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pAccelerationStructure: *mut VkAccelerationStructureNV) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateBuffer(device: VkDevice, pCreateInfo: *const VkBufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pBuffer: *mut VkBuffer) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateBufferView(device: VkDevice, pCreateInfo: *const VkBufferViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkBufferView) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateCommandPool(device: VkDevice, pCreateInfo: *const VkCommandPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pCommandPool: *mut VkCommandPool) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateComputePipelines(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkComputePipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateCuFunctionNVX(device: VkDevice, pCreateInfo: *const VkCuFunctionCreateInfoNVX, pAllocator: *const VkAllocationCallbacks, pFunction: *mut VkCuFunctionNVX) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateCuModuleNVX(device: VkDevice, pCreateInfo: *const VkCuModuleCreateInfoNVX, pAllocator: *const VkAllocationCallbacks, pModule: *mut VkCuModuleNVX) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateDataGraphPipelineSessionARM(device: VkDevice, pCreateInfo: *const VkDataGraphPipelineSessionCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pSession: *mut VkDataGraphPipelineSessionARM) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateDataGraphPipelinesARM(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkDataGraphPipelineCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateDebugReportCallbackEXT(instance: VkInstance, pCreateInfo: *const VkDebugReportCallbackCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pCallback: *mut VkDebugReportCallbackEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateDebugUtilsMessengerEXT(instance: VkInstance, pCreateInfo: *const VkDebugUtilsMessengerCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pMessenger: *mut VkDebugUtilsMessengerEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateDeferredOperationKHR(device: VkDevice, pAllocator: *const VkAllocationCallbacks, pDeferredOperation: *mut VkDeferredOperationKHR) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateDescriptorPool(device: VkDevice, pCreateInfo: *const VkDescriptorPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorPool: *mut VkDescriptorPool) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateDescriptorSetLayout(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pSetLayout: *mut VkDescriptorSetLayout) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateDescriptorUpdateTemplate(device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateDescriptorUpdateTemplateKHR(device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateDevice(physicalDevice: VkPhysicalDevice, pCreateInfo: *const VkDeviceCreateInfo, pAllocator: *const VkAllocationCallbacks, pDevice: *mut VkDevice) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateDisplayModeKHR(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: *const VkDisplayModeCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pMode: *mut VkDisplayModeKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateDisplayPlaneSurfaceKHR(instance: VkInstance, pCreateInfo: *const VkDisplaySurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateEvent(device: VkDevice, pCreateInfo: *const VkEventCreateInfo, pAllocator: *const VkAllocationCallbacks, pEvent: *mut VkEvent) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateExternalComputeQueueNV(device: VkDevice, pCreateInfo: *const VkExternalComputeQueueCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pExternalQueue: *mut VkExternalComputeQueueNV) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateFence(device: VkDevice, pCreateInfo: *const VkFenceCreateInfo, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateFramebuffer(device: VkDevice, pCreateInfo: *const VkFramebufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pFramebuffer: *mut VkFramebuffer) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateGraphicsPipelines(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkGraphicsPipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateHeadlessSurfaceEXT(instance: VkInstance, pCreateInfo: *const VkHeadlessSurfaceCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateImage(device: VkDevice, pCreateInfo: *const VkImageCreateInfo, pAllocator: *const VkAllocationCallbacks, pImage: *mut VkImage) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateImageView(device: VkDevice, pCreateInfo: *const VkImageViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkImageView) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateIndirectCommandsLayoutEXT(device: VkDevice, pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateIndirectCommandsLayoutNV(device: VkDevice, pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutNV) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateIndirectExecutionSetEXT(device: VkDevice, pCreateInfo: *const VkIndirectExecutionSetCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pIndirectExecutionSet: *mut VkIndirectExecutionSetEXT) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateInstance(pCreateInfo: *const VkInstanceCreateInfo, pAllocator: *const VkAllocationCallbacks, pInstance: *mut VkInstance) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateMicromapEXT(device: VkDevice, pCreateInfo: *const VkMicromapCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pMicromap: *mut VkMicromapEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateOpticalFlowSessionNV(device: VkDevice, pCreateInfo: *const VkOpticalFlowSessionCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pSession: *mut VkOpticalFlowSessionNV) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreatePipelineBinariesKHR(device: VkDevice, pCreateInfo: *const VkPipelineBinaryCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pBinaries: *mut VkPipelineBinaryHandlesInfoKHR) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreatePipelineCache(device: VkDevice, pCreateInfo: *const VkPipelineCacheCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineCache: *mut VkPipelineCache) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreatePipelineLayout(device: VkDevice, pCreateInfo: *const VkPipelineLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineLayout: *mut VkPipelineLayout) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreatePrivateDataSlot(device: VkDevice, pCreateInfo: *const VkPrivateDataSlotCreateInfo, pAllocator: *const VkAllocationCallbacks, pPrivateDataSlot: *mut VkPrivateDataSlot) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreatePrivateDataSlotEXT(device: VkDevice, pCreateInfo: *const VkPrivateDataSlotCreateInfo, pAllocator: *const VkAllocationCallbacks, pPrivateDataSlot: *mut VkPrivateDataSlot) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateQueryPool(device: VkDevice, pCreateInfo: *const VkQueryPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pQueryPool: *mut VkQueryPool) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateRayTracingPipelinesKHR(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkRayTracingPipelineCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateRayTracingPipelinesNV(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkRayTracingPipelineCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateRenderPass(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateRenderPass2(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo2, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateRenderPass2KHR(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo2, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateSampler(device: VkDevice, pCreateInfo: *const VkSamplerCreateInfo, pAllocator: *const VkAllocationCallbacks, pSampler: *mut VkSampler) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateSamplerYcbcrConversion(device: VkDevice, pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversion) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateSamplerYcbcrConversionKHR(device: VkDevice, pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversion) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateSemaphore(device: VkDevice, pCreateInfo: *const VkSemaphoreCreateInfo, pAllocator: *const VkAllocationCallbacks, pSemaphore: *mut VkSemaphore) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkCreateShaderModule(device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pAllocator: *const VkAllocationCallbacks, pShaderModule: *mut VkShaderModule) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateShadersEXT(device: VkDevice, createInfoCount: u32, pCreateInfos: *const VkShaderCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pShaders: *mut VkShaderEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateSharedSwapchainsKHR(device: VkDevice, swapchainCount: u32, pCreateInfos: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchains: *mut VkSwapchainKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateSwapchainKHR(device: VkDevice, pCreateInfo: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchain: *mut VkSwapchainKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateTensorARM(device: VkDevice, pCreateInfo: *const VkTensorCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pTensor: *mut VkTensorARM) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateTensorViewARM(device: VkDevice, pCreateInfo: *const VkTensorViewCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pView: *mut VkTensorViewARM) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateValidationCacheEXT(device: VkDevice, pCreateInfo: *const VkValidationCacheCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pValidationCache: *mut VkValidationCacheEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateVideoSessionKHR(device: VkDevice, pCreateInfo: *const VkVideoSessionCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pVideoSession: *mut VkVideoSessionKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkCreateVideoSessionParametersKHR(device: VkDevice, pCreateInfo: *const VkVideoSessionParametersCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pVideoSessionParameters: *mut VkVideoSessionParametersKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDebugMarkerSetObjectNameEXT(device: VkDevice, pNameInfo: *const VkDebugMarkerObjectNameInfoEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDebugMarkerSetObjectTagEXT(device: VkDevice, pTagInfo: *const VkDebugMarkerObjectTagInfoEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDebugReportMessageEXT(instance: VkInstance, flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, object: u64, location: usize, messageCode: i32, pLayerPrefix: *const c_char, pMessage: *const c_char);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDeferredOperationJoinKHR(device: VkDevice, operation: VkDeferredOperationKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyAccelerationStructureKHR(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyAccelerationStructureNV(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyBuffer(device: VkDevice, buffer: VkBuffer, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyBufferView(device: VkDevice, bufferView: VkBufferView, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyCommandPool(device: VkDevice, commandPool: VkCommandPool, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyCuFunctionNVX(device: VkDevice, function: VkCuFunctionNVX, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyCuModuleNVX(device: VkDevice, module: VkCuModuleNVX, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyDataGraphPipelineSessionARM(device: VkDevice, session: VkDataGraphPipelineSessionARM, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyDebugReportCallbackEXT(instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyDebugUtilsMessengerEXT(instance: VkInstance, messenger: VkDebugUtilsMessengerEXT, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyDeferredOperationKHR(device: VkDevice, operation: VkDeferredOperationKHR, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyDescriptorPool(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyDescriptorSetLayout(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyDescriptorUpdateTemplate(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyDescriptorUpdateTemplateKHR(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyDevice(device: VkDevice, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyEvent(device: VkDevice, event: VkEvent, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyExternalComputeQueueNV(device: VkDevice, externalQueue: VkExternalComputeQueueNV, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyFence(device: VkDevice, fence: VkFence, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyFramebuffer(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyImage(device: VkDevice, image: VkImage, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyImageView(device: VkDevice, imageView: VkImageView, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyIndirectCommandsLayoutEXT(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutEXT, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyIndirectCommandsLayoutNV(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutNV, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyIndirectExecutionSetEXT(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyInstance(instance: VkInstance, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyMicromapEXT(device: VkDevice, micromap: VkMicromapEXT, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyOpticalFlowSessionNV(device: VkDevice, session: VkOpticalFlowSessionNV, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyPipeline(device: VkDevice, pipeline: VkPipeline, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyPipelineBinaryKHR(device: VkDevice, pipelineBinary: VkPipelineBinaryKHR, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyPipelineCache(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyPipelineLayout(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyPrivateDataSlot(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyPrivateDataSlotEXT(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyQueryPool(device: VkDevice, queryPool: VkQueryPool, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyRenderPass(device: VkDevice, renderPass: VkRenderPass, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroySampler(device: VkDevice, sampler: VkSampler, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroySamplerYcbcrConversion(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroySamplerYcbcrConversionKHR(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroySemaphore(device: VkDevice, semaphore: VkSemaphore, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyShaderEXT(device: VkDevice, shader: VkShaderEXT, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDestroyShaderModule(device: VkDevice, shaderModule: VkShaderModule, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroySurfaceKHR(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroySwapchainKHR(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyTensorARM(device: VkDevice, tensor: VkTensorARM, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyTensorViewARM(device: VkDevice, tensorView: VkTensorViewARM, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyValidationCacheEXT(device: VkDevice, validationCache: VkValidationCacheEXT, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyVideoSessionKHR(device: VkDevice, videoSession: VkVideoSessionKHR, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDestroyVideoSessionParametersKHR(device: VkDevice, videoSessionParameters: VkVideoSessionParametersKHR, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkDeviceWaitIdle(device: VkDevice) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkDisplayPowerControlEXT(device: VkDevice, display: VkDisplayKHR, pDisplayPowerInfo: *const VkDisplayPowerInfoEXT) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkEndCommandBuffer(commandBuffer: VkCommandBuffer) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkEnumerateDeviceExtensionProperties(physicalDevice: VkPhysicalDevice, pLayerName: *const c_char, pPropertyCount: *mut u32, pProperties: *mut VkExtensionProperties) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkEnumerateDeviceLayerProperties(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkLayerProperties) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkEnumerateInstanceExtensionProperties(pLayerName: *const c_char, pPropertyCount: *mut u32, pProperties: *mut VkExtensionProperties) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkEnumerateInstanceLayerProperties(pPropertyCount: *mut u32, pProperties: *mut VkLayerProperties) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkEnumerateInstanceVersion(pApiVersion: *mut u32) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkEnumeratePhysicalDeviceGroups(instance: VkInstance, pPhysicalDeviceGroupCount: *mut u32, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupProperties) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkEnumeratePhysicalDeviceGroupsKHR(instance: VkInstance, pPhysicalDeviceGroupCount: *mut u32, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupProperties) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pCounterCount: *mut u32, pCounters: *mut VkPerformanceCounterARM, pCounterDescriptions: *mut VkPerformanceCounterDescriptionARM) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pCounterCount: *mut u32, pCounters: *mut VkPerformanceCounterKHR, pCounterDescriptions: *mut VkPerformanceCounterDescriptionKHR) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkEnumeratePhysicalDevices(instance: VkInstance, pPhysicalDeviceCount: *mut u32, pPhysicalDevices: *mut VkPhysicalDevice) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkFlushMappedMemoryRanges(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkFreeCommandBuffers(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: u32, pCommandBuffers: *const VkCommandBuffer);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkFreeDescriptorSets(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: u32, pDescriptorSets: *const VkDescriptorSet) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkFreeMemory(device: VkDevice, memory: VkDeviceMemory, pAllocator: *const VkAllocationCallbacks);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetAccelerationStructureBuildSizesKHR(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: *const VkAccelerationStructureBuildGeometryInfoKHR, pMaxPrimitiveCounts: *const u32, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetAccelerationStructureDeviceAddressKHR(device: VkDevice, pInfo: *const VkAccelerationStructureDeviceAddressInfoKHR) -> VkDeviceAddress;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetAccelerationStructureHandleNV(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, dataSize: usize, pData: *mut c_void) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetAccelerationStructureMemoryRequirementsNV(device: VkDevice, pInfo: *const VkAccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: *mut VkMemoryRequirements2KHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(device: VkDevice, pInfo: *const VkAccelerationStructureCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetBufferDeviceAddress(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetBufferDeviceAddressEXT(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetBufferDeviceAddressKHR(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetBufferMemoryRequirements(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: *mut VkMemoryRequirements);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetBufferMemoryRequirements2(device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetBufferMemoryRequirements2KHR(device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetBufferOpaqueCaptureAddress(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> u64;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetBufferOpaqueCaptureAddressKHR(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> u64;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetBufferOpaqueCaptureDescriptorDataEXT(device: VkDevice, pInfo: *const VkBufferCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetCalibratedTimestampsEXT(device: VkDevice, timestampCount: u32, pTimestampInfos: *const VkCalibratedTimestampInfoKHR, pTimestamps: *mut u64, pMaxDeviation: *mut u64) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetCalibratedTimestampsKHR(device: VkDevice, timestampCount: u32, pTimestampInfos: *const VkCalibratedTimestampInfoKHR, pTimestamps: *mut u64, pMaxDeviation: *mut u64) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetClusterAccelerationStructureBuildSizesNV(device: VkDevice, pInfo: *const VkClusterAccelerationStructureInputInfoNV, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDataGraphPipelineAvailablePropertiesARM(device: VkDevice, pPipelineInfo: *const VkDataGraphPipelineInfoARM, pPropertiesCount: *mut u32, pProperties: *mut VkDataGraphPipelinePropertyARM) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDataGraphPipelinePropertiesARM(device: VkDevice, pPipelineInfo: *const VkDataGraphPipelineInfoARM, propertiesCount: u32, pProperties: *mut VkDataGraphPipelinePropertyQueryResultARM) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDataGraphPipelineSessionBindPointRequirementsARM(device: VkDevice, pInfo: *const VkDataGraphPipelineSessionBindPointRequirementsInfoARM, pBindPointRequirementCount: *mut u32, pBindPointRequirements: *mut VkDataGraphPipelineSessionBindPointRequirementARM) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDataGraphPipelineSessionMemoryRequirementsARM(device: VkDevice, pInfo: *const VkDataGraphPipelineSessionMemoryRequirementsInfoARM, pMemoryRequirements: *mut VkMemoryRequirements2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDeferredOperationMaxConcurrencyKHR(device: VkDevice, operation: VkDeferredOperationKHR) -> u32;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDeferredOperationResultKHR(device: VkDevice, operation: VkDeferredOperationKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDescriptorEXT(device: VkDevice, pDescriptorInfo: *const VkDescriptorGetInfoEXT, dataSize: usize, pDescriptor: *mut c_void);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDescriptorSetHostMappingVALVE(device: VkDevice, descriptorSet: VkDescriptorSet, ppData: *mut *mut c_void);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDescriptorSetLayoutBindingOffsetEXT(device: VkDevice, layout: VkDescriptorSetLayout, binding: u32, pOffset: *mut VkDeviceSize);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDescriptorSetLayoutHostMappingInfoVALVE(device: VkDevice, pBindingReference: *const VkDescriptorSetBindingReferenceVALVE, pHostMapping: *mut VkDescriptorSetLayoutHostMappingInfoVALVE);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDescriptorSetLayoutSizeEXT(device: VkDevice, layout: VkDescriptorSetLayout, pLayoutSizeInBytes: *mut VkDeviceSize);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetDescriptorSetLayoutSupport(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDescriptorSetLayoutSupportKHR(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDeviceAccelerationStructureCompatibilityKHR(device: VkDevice, pVersionInfo: *const VkAccelerationStructureVersionInfoKHR, pCompatibility: *mut VkAccelerationStructureCompatibilityKHR);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetDeviceBufferMemoryRequirements(device: VkDevice, pInfo: *const VkDeviceBufferMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDeviceBufferMemoryRequirementsKHR(device: VkDevice, pInfo: *const VkDeviceBufferMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDeviceFaultInfoEXT(device: VkDevice, pFaultCounts: *mut VkDeviceFaultCountsEXT, pFaultInfo: *mut VkDeviceFaultInfoEXT) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetDeviceGroupPeerMemoryFeatures(device: VkDevice, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDeviceGroupPeerMemoryFeaturesKHR(device: VkDevice, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDeviceGroupPresentCapabilitiesKHR(device: VkDevice, pDeviceGroupPresentCapabilities: *mut VkDeviceGroupPresentCapabilitiesKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDeviceGroupSurfacePresentModesKHR(device: VkDevice, surface: VkSurfaceKHR, pModes: *mut VkDeviceGroupPresentModeFlagsKHR) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetDeviceImageMemoryRequirements(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDeviceImageMemoryRequirementsKHR(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetDeviceImageSparseMemoryRequirements(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDeviceImageSparseMemoryRequirementsKHR(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetDeviceImageSubresourceLayout(device: VkDevice, pInfo: *const VkDeviceImageSubresourceInfo, pLayout: *mut VkSubresourceLayout2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDeviceImageSubresourceLayoutKHR(device: VkDevice, pInfo: *const VkDeviceImageSubresourceInfo, pLayout: *mut VkSubresourceLayout2);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetDeviceMemoryCommitment(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: *mut VkDeviceSize);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetDeviceMemoryOpaqueCaptureAddress(device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo) -> u64;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDeviceMemoryOpaqueCaptureAddressKHR(device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo) -> u64;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDeviceMicromapCompatibilityEXT(device: VkDevice, pVersionInfo: *const VkMicromapVersionInfoEXT, pCompatibility: *mut VkAccelerationStructureCompatibilityKHR);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetDeviceProcAddr(device: VkDevice, pName: *const c_char) -> PFN_vkVoidFunction;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetDeviceQueue(device: VkDevice, queueFamilyIndex: u32, queueIndex: u32, pQueue: *mut VkQueue);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetDeviceQueue2(device: VkDevice, pQueueInfo: *const VkDeviceQueueInfo2, pQueue: *mut VkQueue);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device: VkDevice, renderpass: VkRenderPass, pMaxWorkgroupSize: *mut VkExtent2D) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDeviceTensorMemoryRequirementsARM(device: VkDevice, pInfo: *const VkDeviceTensorMemoryRequirementsARM, pMemoryRequirements: *mut VkMemoryRequirements2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDisplayModeProperties2KHR(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut u32, pProperties: *mut VkDisplayModeProperties2KHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDisplayModePropertiesKHR(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut u32, pProperties: *mut VkDisplayModePropertiesKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDisplayPlaneCapabilities2KHR(physicalDevice: VkPhysicalDevice, pDisplayPlaneInfo: *const VkDisplayPlaneInfo2KHR, pCapabilities: *mut VkDisplayPlaneCapabilities2KHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDisplayPlaneCapabilitiesKHR(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: u32, pCapabilities: *mut VkDisplayPlaneCapabilitiesKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice: VkPhysicalDevice, planeIndex: u32, pDisplayCount: *mut u32, pDisplays: *mut VkDisplayKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDrmDisplayEXT(physicalDevice: VkPhysicalDevice, drmFd: i32, connectorId: u32, display: *mut VkDisplayKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetDynamicRenderingTilePropertiesQCOM(device: VkDevice, pRenderingInfo: *const VkRenderingInfo, pProperties: *mut VkTilePropertiesQCOM) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetEncodedVideoSessionParametersKHR(device: VkDevice, pVideoSessionParametersInfo: *const VkVideoEncodeSessionParametersGetInfoKHR, pFeedbackInfo: *mut VkVideoEncodeSessionParametersFeedbackInfoKHR, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetEventStatus(device: VkDevice, event: VkEvent) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetExternalComputeQueueDataNV(externalQueue: VkExternalComputeQueueNV, params: *mut VkExternalComputeQueueDataParamsNV, pData: *mut c_void);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetFenceFdKHR(device: VkDevice, pGetFdInfo: *const VkFenceGetFdInfoKHR, pFd: *mut c_int) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetFenceStatus(device: VkDevice, fence: VkFence) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetFramebufferTilePropertiesQCOM(device: VkDevice, framebuffer: VkFramebuffer, pPropertiesCount: *mut u32, pProperties: *mut VkTilePropertiesQCOM) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetGeneratedCommandsMemoryRequirementsEXT(device: VkDevice, pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoEXT, pMemoryRequirements: *mut VkMemoryRequirements2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetGeneratedCommandsMemoryRequirementsNV(device: VkDevice, pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: *mut VkMemoryRequirements2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetImageDrmFormatModifierPropertiesEXT(device: VkDevice, image: VkImage, pProperties: *mut VkImageDrmFormatModifierPropertiesEXT) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetImageMemoryRequirements(device: VkDevice, image: VkImage, pMemoryRequirements: *mut VkMemoryRequirements);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetImageMemoryRequirements2(device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetImageMemoryRequirements2KHR(device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetImageOpaqueCaptureDescriptorDataEXT(device: VkDevice, pInfo: *const VkImageCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetImageSparseMemoryRequirements(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetImageSparseMemoryRequirements2(device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetImageSparseMemoryRequirements2KHR(device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetImageSubresourceLayout(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource, pLayout: *mut VkSubresourceLayout);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetImageSubresourceLayout2(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetImageSubresourceLayout2EXT(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetImageSubresourceLayout2KHR(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetImageViewAddressNVX(device: VkDevice, imageView: VkImageView, pProperties: *mut VkImageViewAddressPropertiesNVX) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetImageViewHandle64NVX(device: VkDevice, pInfo: *const VkImageViewHandleInfoNVX) -> u64;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetImageViewHandleNVX(device: VkDevice, pInfo: *const VkImageViewHandleInfoNVX) -> u32;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetImageViewOpaqueCaptureDescriptorDataEXT(device: VkDevice, pInfo: *const VkImageViewCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetInstanceProcAddr(instance: VkInstance, pName: *const c_char) -> PFN_vkVoidFunction;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetLatencyTimingsNV(device: VkDevice, swapchain: VkSwapchainKHR, pLatencyMarkerInfo: *mut VkGetLatencyMarkerInfoNV);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetMemoryFdKHR(device: VkDevice, pGetFdInfo: *const VkMemoryGetFdInfoKHR, pFd: *mut c_int) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetMemoryFdPropertiesKHR(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, fd: c_int, pMemoryFdProperties: *mut VkMemoryFdPropertiesKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetMemoryHostPointerPropertiesEXT(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, pHostPointer: *const c_void, pMemoryHostPointerProperties: *mut VkMemoryHostPointerPropertiesEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetMemoryRemoteAddressNV(device: VkDevice, pMemoryGetRemoteAddressInfo: *const VkMemoryGetRemoteAddressInfoNV, pAddress: *mut VkRemoteAddressNV) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetMicromapBuildSizesEXT(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: *const VkMicromapBuildInfoEXT, pSizeInfo: *mut VkMicromapBuildSizesInfoEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPartitionedAccelerationStructuresBuildSizesNV(device: VkDevice, pInfo: *const VkPartitionedAccelerationStructureInstancesInputNV, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPastPresentationTimingEXT(device: VkDevice, pPastPresentationTimingInfo: *const VkPastPresentationTimingInfoEXT, pPastPresentationTimingProperties: *mut VkPastPresentationTimingPropertiesEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPastPresentationTimingGOOGLE(device: VkDevice, swapchain: VkSwapchainKHR, pPresentationTimingCount: *mut u32, pPresentationTimings: *mut VkPastPresentationTimingGOOGLE) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPerformanceParameterINTEL(device: VkDevice, parameter: VkPerformanceParameterTypeINTEL, pValue: *mut VkPerformanceValueINTEL) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice: VkPhysicalDevice, pTimeDomainCount: *mut u32, pTimeDomains: *mut VkTimeDomainKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(physicalDevice: VkPhysicalDevice, pTimeDomainCount: *mut u32, pTimeDomains: *mut VkTimeDomainKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixFlexibleDimensionsPropertiesNV) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixPropertiesKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixPropertiesNV) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceCooperativeVectorPropertiesNV(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeVectorPropertiesNV) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPlaneProperties2KHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPlanePropertiesKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayProperties2KHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPropertiesKHR) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceExternalBufferProperties(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: *mut VkExternalBufferProperties);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: *mut VkExternalBufferProperties);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceExternalFenceProperties(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: *mut VkExternalFenceProperties);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: *mut VkExternalFenceProperties);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice: VkPhysicalDevice, format: VkFormat, typ: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, externalHandleType: VkExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: *mut VkExternalImageFormatPropertiesNV) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceExternalTensorPropertiesARM(physicalDevice: VkPhysicalDevice, pExternalTensorInfo: *const VkPhysicalDeviceExternalTensorInfoARM, pExternalTensorProperties: *mut VkExternalTensorPropertiesARM);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceFeatures(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceFeatures2(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceFeatures2KHR(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceFormatProperties(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceFormatProperties2(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice: VkPhysicalDevice, pFragmentShadingRateCount: *mut u32, pFragmentShadingRates: *mut VkPhysicalDeviceFragmentShadingRateKHR) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceImageFormatProperties(physicalDevice: VkPhysicalDevice, format: VkFormat, typ: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: *mut VkImageFormatProperties) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceImageFormatProperties2(physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: *mut VkImageFormatProperties2) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: *mut VkImageFormatProperties2) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceMemoryProperties(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceMemoryProperties2(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice: VkPhysicalDevice, samples: VkSampleCountFlagBits, pMultisampleProperties: *mut VkMultisamplePropertiesEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceOpticalFlowImageFormatsNV(physicalDevice: VkPhysicalDevice, pOpticalFlowImageFormatInfo: *const VkOpticalFlowImageFormatInfoNV, pFormatCount: *mut u32, pImageFormatProperties: *mut VkOpticalFlowImageFormatPropertiesNV) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: *mut u32, pRects: *mut VkRect2D) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceProperties(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceProperties2(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceProperties2KHR(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(physicalDevice: VkPhysicalDevice, pQueueFamilyDataGraphProcessingEngineInfo: *const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM, pQueueFamilyDataGraphProcessingEngineProperties: *mut VkQueueFamilyDataGraphProcessingEnginePropertiesARM);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pQueueFamilyDataGraphPropertyCount: *mut u32, pQueueFamilyDataGraphProperties: *mut VkQueueFamilyDataGraphPropertiesARM) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice: VkPhysicalDevice, pPerformanceQueryCreateInfo: *const VkQueryPoolPerformanceCreateInfoKHR, pNumPasses: *mut u32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties2);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice: VkPhysicalDevice, format: VkFormat, typ: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice: VkPhysicalDevice, pCombinationCount: *mut u32, pCombinations: *mut VkFramebufferMixedSamplesCombinationNV) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2EXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2KHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilitiesKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceFormatCount: *mut u32, pSurfaceFormats: *mut VkSurfaceFormat2KHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: *mut u32, pSurfaceFormats: *mut VkSurfaceFormatKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: *mut u32, pPresentModes: *mut VkPresentModeKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, surface: VkSurfaceKHR, pSupported: *mut VkBool32) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPhysicalDeviceToolProperties(physicalDevice: VkPhysicalDevice, pToolCount: *mut u32, pToolProperties: *mut VkPhysicalDeviceToolProperties) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice: VkPhysicalDevice, pToolCount: *mut u32, pToolProperties: *mut VkPhysicalDeviceToolProperties) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice: VkPhysicalDevice, pVideoProfile: *const VkVideoProfileInfoKHR, pCapabilities: *mut VkVideoCapabilitiesKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(physicalDevice: VkPhysicalDevice, pQualityLevelInfo: *const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR, pQualityLevelProperties: *mut VkVideoEncodeQualityLevelPropertiesKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice: VkPhysicalDevice, pVideoFormatInfo: *const VkPhysicalDeviceVideoFormatInfoKHR, pVideoFormatPropertyCount: *mut u32, pVideoFormatProperties: *mut VkVideoFormatPropertiesKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPipelineBinaryDataKHR(device: VkDevice, pInfo: *const VkPipelineBinaryDataInfoKHR, pPipelineBinaryKey: *mut VkPipelineBinaryKeyKHR, pPipelineBinaryDataSize: *mut usize, pPipelineBinaryData: *mut c_void) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPipelineCacheData(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPipelineExecutableInternalRepresentationsKHR(device: VkDevice, pExecutableInfo: *const VkPipelineExecutableInfoKHR, pInternalRepresentationCount: *mut u32, pInternalRepresentations: *mut VkPipelineExecutableInternalRepresentationKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPipelineExecutablePropertiesKHR(device: VkDevice, pPipelineInfo: *const VkPipelineInfoKHR, pExecutableCount: *mut u32, pProperties: *mut VkPipelineExecutablePropertiesKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPipelineExecutableStatisticsKHR(device: VkDevice, pExecutableInfo: *const VkPipelineExecutableInfoKHR, pStatisticCount: *mut u32, pStatistics: *mut VkPipelineExecutableStatisticKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPipelineIndirectDeviceAddressNV(device: VkDevice, pInfo: *const VkPipelineIndirectDeviceAddressInfoNV) -> VkDeviceAddress;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPipelineIndirectMemoryRequirementsNV(device: VkDevice, pCreateInfo: *const VkComputePipelineCreateInfo, pMemoryRequirements: *mut VkMemoryRequirements2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPipelineKeyKHR(device: VkDevice, pPipelineCreateInfo: *const VkPipelineCreateInfoKHR, pPipelineKey: *mut VkPipelineBinaryKeyKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPipelinePropertiesEXT(device: VkDevice, pPipelineInfo: *const VkPipelineInfoEXT, pPipelineProperties: *mut VkBaseOutStructure) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetPrivateData(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, pData: *mut u64);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetPrivateDataEXT(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, pData: *mut u64);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetQueryPoolResults(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dataSize: usize, pData: *mut c_void, stride: VkDeviceSize, flags: VkQueryResultFlags) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetQueueCheckpointData2NV(queue: VkQueue, pCheckpointDataCount: *mut u32, pCheckpointData: *mut VkCheckpointData2NV);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetQueueCheckpointDataNV(queue: VkQueue, pCheckpointDataCount: *mut u32, pCheckpointData: *mut VkCheckpointDataNV);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetRayTracingShaderGroupHandlesKHR(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetRayTracingShaderGroupHandlesNV(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetRayTracingShaderGroupStackSizeKHR(device: VkDevice, pipeline: VkPipeline, group: u32, groupShader: VkShaderGroupShaderKHR) -> VkDeviceSize;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetRefreshCycleDurationGOOGLE(device: VkDevice, swapchain: VkSwapchainKHR, pDisplayTimingProperties: *mut VkRefreshCycleDurationGOOGLE) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetRenderAreaGranularity(device: VkDevice, renderPass: VkRenderPass, pGranularity: *mut VkExtent2D);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetRenderingAreaGranularity(device: VkDevice, pRenderingAreaInfo: *const VkRenderingAreaInfo, pGranularity: *mut VkExtent2D);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetRenderingAreaGranularityKHR(device: VkDevice, pRenderingAreaInfo: *const VkRenderingAreaInfo, pGranularity: *mut VkExtent2D);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetSamplerOpaqueCaptureDescriptorDataEXT(device: VkDevice, pInfo: *const VkSamplerCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkGetSemaphoreCounterValue(device: VkDevice, semaphore: VkSemaphore, pValue: *mut u64) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetSemaphoreCounterValueKHR(device: VkDevice, semaphore: VkSemaphore, pValue: *mut u64) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetSemaphoreFdKHR(device: VkDevice, pGetFdInfo: *const VkSemaphoreGetFdInfoKHR, pFd: *mut c_int) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetShaderBinaryDataEXT(device: VkDevice, shader: VkShaderEXT, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetShaderInfoAMD(device: VkDevice, pipeline: VkPipeline, shaderStage: VkShaderStageFlagBits, infoType: VkShaderInfoTypeAMD, pInfoSize: *mut usize, pInfo: *mut c_void) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetShaderModuleCreateInfoIdentifierEXT(device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pIdentifier: *mut VkShaderModuleIdentifierEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetShaderModuleIdentifierEXT(device: VkDevice, shaderModule: VkShaderModule, pIdentifier: *mut VkShaderModuleIdentifierEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetSwapchainCounterEXT(device: VkDevice, swapchain: VkSwapchainKHR, counter: VkSurfaceCounterFlagBitsEXT, pCounterValue: *mut u64) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetSwapchainImagesKHR(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: *mut u32, pSwapchainImages: *mut VkImage) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetSwapchainStatusKHR(device: VkDevice, swapchain: VkSwapchainKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetSwapchainTimeDomainPropertiesEXT(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainTimeDomainProperties: *mut VkSwapchainTimeDomainPropertiesEXT, pTimeDomainsCounter: *mut u64) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetSwapchainTimingPropertiesEXT(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainTimingProperties: *mut VkSwapchainTimingPropertiesEXT, pSwapchainTimingPropertiesCounter: *mut u64) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetTensorMemoryRequirementsARM(device: VkDevice, pInfo: *const VkTensorMemoryRequirementsInfoARM, pMemoryRequirements: *mut VkMemoryRequirements2);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetTensorOpaqueCaptureDescriptorDataARM(device: VkDevice, pInfo: *const VkTensorCaptureDescriptorDataInfoARM, pData: *mut c_void) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetTensorViewOpaqueCaptureDescriptorDataARM(device: VkDevice, pInfo: *const VkTensorViewCaptureDescriptorDataInfoARM, pData: *mut c_void) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetValidationCacheDataEXT(device: VkDevice, validationCache: VkValidationCacheEXT, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkGetVideoSessionMemoryRequirementsKHR(device: VkDevice, videoSession: VkVideoSessionKHR, pMemoryRequirementsCount: *mut u32, pMemoryRequirements: *mut VkVideoSessionMemoryRequirementsKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkImportFenceFdKHR(device: VkDevice, pImportFenceFdInfo: *const VkImportFenceFdInfoKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkImportSemaphoreFdKHR(device: VkDevice, pImportSemaphoreFdInfo: *const VkImportSemaphoreFdInfoKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkInitializePerformanceApiINTEL(device: VkDevice, pInitializeInfo: *const VkInitializePerformanceApiInfoINTEL) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkInvalidateMappedMemoryRanges(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkLatencySleepNV(device: VkDevice, swapchain: VkSwapchainKHR, pSleepInfo: *const VkLatencySleepInfoNV) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkMapMemory(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: *mut *mut c_void) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkMapMemory2(device: VkDevice, pMemoryMapInfo: *const VkMemoryMapInfo, ppData: *mut *mut c_void) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkMapMemory2KHR(device: VkDevice, pMemoryMapInfo: *const VkMemoryMapInfo, ppData: *mut *mut c_void) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkMergePipelineCaches(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: u32, pSrcCaches: *const VkPipelineCache) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkMergeValidationCachesEXT(device: VkDevice, dstCache: VkValidationCacheEXT, srcCacheCount: u32, pSrcCaches: *const VkValidationCacheEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkQueueBeginDebugUtilsLabelEXT(queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkQueueBindSparse(queue: VkQueue, bindInfoCount: u32, pBindInfo: *const VkBindSparseInfo, fence: VkFence) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkQueueEndDebugUtilsLabelEXT(queue: VkQueue);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkQueueInsertDebugUtilsLabelEXT(queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkQueueNotifyOutOfBandNV(queue: VkQueue, pQueueTypeInfo: *const VkOutOfBandQueueTypeInfoNV);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkQueuePresentKHR(queue: VkQueue, pPresentInfo: *const VkPresentInfoKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkQueueSetPerformanceConfigurationINTEL(queue: VkQueue, configuration: VkPerformanceConfigurationINTEL) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkQueueSubmit(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo, fence: VkFence) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkQueueSubmit2(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo2, fence: VkFence) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkQueueSubmit2KHR(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo2, fence: VkFence) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkQueueWaitIdle(queue: VkQueue) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkRegisterDeviceEventEXT(device: VkDevice, pDeviceEventInfo: *const VkDeviceEventInfoEXT, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkRegisterDisplayEventEXT(device: VkDevice, display: VkDisplayKHR, pDisplayEventInfo: *const VkDisplayEventInfoEXT, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkReleaseCapturedPipelineDataKHR(device: VkDevice, pInfo: *const VkReleaseCapturedPipelineDataInfoKHR, pAllocator: *const VkAllocationCallbacks) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkReleaseDisplayEXT(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkReleasePerformanceConfigurationINTEL(device: VkDevice, configuration: VkPerformanceConfigurationINTEL) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkReleaseProfilingLockKHR(device: VkDevice);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkReleaseSwapchainImagesEXT(device: VkDevice, pReleaseInfo: *const VkReleaseSwapchainImagesInfoKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkReleaseSwapchainImagesKHR(device: VkDevice, pReleaseInfo: *const VkReleaseSwapchainImagesInfoKHR) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkResetCommandBuffer(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkResetCommandPool(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkResetDescriptorPool(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkResetEvent(device: VkDevice, event: VkEvent) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkResetFences(device: VkDevice, fenceCount: u32, pFences: *const VkFence) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkResetQueryPool(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkResetQueryPoolEXT(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkSetDebugUtilsObjectNameEXT(device: VkDevice, pNameInfo: *const VkDebugUtilsObjectNameInfoEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkSetDebugUtilsObjectTagEXT(device: VkDevice, pTagInfo: *const VkDebugUtilsObjectTagInfoEXT) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkSetDeviceMemoryPriorityEXT(device: VkDevice, memory: VkDeviceMemory, priority: f32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkSetEvent(device: VkDevice, event: VkEvent) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkSetHdrMetadataEXT(device: VkDevice, swapchainCount: u32, pSwapchains: *const VkSwapchainKHR, pMetadata: *const VkHdrMetadataEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkSetLatencyMarkerNV(device: VkDevice, swapchain: VkSwapchainKHR, pLatencyMarkerInfo: *const VkSetLatencyMarkerInfoNV);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkSetLatencySleepModeNV(device: VkDevice, swapchain: VkSwapchainKHR, pSleepModeInfo: *const VkLatencySleepModeInfoNV) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkSetLocalDimmingAMD(device: VkDevice, swapChain: VkSwapchainKHR, localDimmingEnable: VkBool32);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkSetPrivateData(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, data: u64) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkSetPrivateDataEXT(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, data: u64) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkSetSwapchainPresentTimingQueueSizeEXT(device: VkDevice, swapchain: VkSwapchainKHR, size: u32) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkSignalSemaphore(device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfo) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkSignalSemaphoreKHR(device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfo) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkSubmitDebugUtilsMessageEXT(instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: *const VkDebugUtilsMessengerCallbackDataEXT);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkTransitionImageLayout(device: VkDevice, transitionCount: u32, pTransitions: *const VkHostImageLayoutTransitionInfo) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkTransitionImageLayoutEXT(device: VkDevice, transitionCount: u32, pTransitions: *const VkHostImageLayoutTransitionInfo) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkTrimCommandPool(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkTrimCommandPoolKHR(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkUninitializePerformanceApiINTEL(device: VkDevice);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkUnmapMemory(device: VkDevice, memory: VkDeviceMemory);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkUnmapMemory2(device: VkDevice, pMemoryUnmapInfo: *const VkMemoryUnmapInfo) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkUnmapMemory2KHR(device: VkDevice, pMemoryUnmapInfo: *const VkMemoryUnmapInfo) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkUpdateDescriptorSetWithTemplate(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: *const c_void);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkUpdateDescriptorSetWithTemplateKHR(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: *const c_void);

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkUpdateDescriptorSets(device: VkDevice, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet, descriptorCopyCount: u32, pDescriptorCopies: *const VkCopyDescriptorSet);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkUpdateIndirectExecutionSetPipelineEXT(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, executionSetWriteCount: u32, pExecutionSetWrites: *const VkWriteIndirectExecutionSetPipelineEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkUpdateIndirectExecutionSetShaderEXT(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, executionSetWriteCount: u32, pExecutionSetWrites: *const VkWriteIndirectExecutionSetShaderEXT);

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkUpdateVideoSessionParametersKHR(device: VkDevice, videoSessionParameters: VkVideoSessionParametersKHR, pUpdateInfo: *const VkVideoSessionParametersUpdateInfoKHR) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkWaitForFences(device: VkDevice, fenceCount: u32, pFences: *const VkFence, waitAll: VkBool32, timeout: u64) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkWaitForPresent2KHR(device: VkDevice, swapchain: VkSwapchainKHR, pPresentWait2Info: *const VkPresentWait2InfoKHR) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkWaitForPresentKHR(device: VkDevice, swapchain: VkSwapchainKHR, presentId: u64, timeout: u64) -> VkResult;

    /// Available if built with `exported-prototypes`.
    #[cfg(any(doc, feature = "exported-prototypes"))]
    pub fn vkWaitSemaphores(device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfo, timeout: u64) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkWaitSemaphoresKHR(device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfo, timeout: u64) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkWriteAccelerationStructuresPropertiesKHR(device: VkDevice, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureKHR, queryType: VkQueryType, dataSize: usize, pData: *mut c_void, stride: usize) -> VkResult;

    /// Available if built with `prototypes`.
    #[cfg(any(doc, feature = "prototypes"))]
    pub fn vkWriteMicromapsPropertiesEXT(device: VkDevice, micromapCount: u32, pMicromaps: *const VkMicromapEXT, queryType: VkQueryType, dataSize: usize, pData: *mut c_void, stride: usize) -> VkResult;
}

pub type NonNullPFN_vkAcquireDrmDisplayEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, drmFd: i32, display: VkDisplayKHR) -> VkResult;
pub type NonNullPFN_vkAcquireNextImage2KHR = unsafe extern "system" fn(device: VkDevice, pAcquireInfo: *const VkAcquireNextImageInfoKHR, pImageIndex: *mut u32) -> VkResult;
pub type NonNullPFN_vkAcquireNextImageKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, timeout: u64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: *mut u32) -> VkResult;
pub type NonNullPFN_vkAcquirePerformanceConfigurationINTEL = unsafe extern "system" fn(device: VkDevice, pAcquireInfo: *const VkPerformanceConfigurationAcquireInfoINTEL, pConfiguration: *mut VkPerformanceConfigurationINTEL) -> VkResult;
pub type NonNullPFN_vkAcquireProfilingLockKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkAcquireProfilingLockInfoKHR) -> VkResult;
pub type NonNullPFN_vkAllocateCommandBuffers = unsafe extern "system" fn(device: VkDevice, pAllocateInfo: *const VkCommandBufferAllocateInfo, pCommandBuffers: *mut VkCommandBuffer) -> VkResult;
pub type NonNullPFN_vkAllocateDescriptorSets = unsafe extern "system" fn(device: VkDevice, pAllocateInfo: *const VkDescriptorSetAllocateInfo, pDescriptorSets: *mut VkDescriptorSet) -> VkResult;
pub type NonNullPFN_vkAllocateMemory = unsafe extern "system" fn(device: VkDevice, pAllocateInfo: *const VkMemoryAllocateInfo, pAllocator: *const VkAllocationCallbacks, pMemory: *mut VkDeviceMemory) -> VkResult;
pub type NonNullPFN_vkAllocationFunction = unsafe extern "system" fn(pUserData: *mut c_void, size: usize, alignment: usize, allocationScope: VkSystemAllocationScope) -> *mut c_void;
pub type NonNullPFN_vkAntiLagUpdateAMD = unsafe extern "system" fn(device: VkDevice, pData: *const VkAntiLagDataAMD);
pub type NonNullPFN_vkBeginCommandBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBeginInfo: *const VkCommandBufferBeginInfo) -> VkResult;
pub type NonNullPFN_vkBindAccelerationStructureMemoryNV = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindAccelerationStructureMemoryInfoNV) -> VkResult;
pub type NonNullPFN_vkBindBufferMemory = unsafe extern "system" fn(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult;
pub type NonNullPFN_vkBindBufferMemory2 = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindBufferMemoryInfo) -> VkResult;
pub type NonNullPFN_vkBindBufferMemory2KHR = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindBufferMemoryInfo) -> VkResult;
pub type NonNullPFN_vkBindDataGraphPipelineSessionMemoryARM = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindDataGraphPipelineSessionMemoryInfoARM) -> VkResult;
pub type NonNullPFN_vkBindImageMemory = unsafe extern "system" fn(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult;
pub type NonNullPFN_vkBindImageMemory2 = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindImageMemoryInfo) -> VkResult;
pub type NonNullPFN_vkBindImageMemory2KHR = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindImageMemoryInfo) -> VkResult;
pub type NonNullPFN_vkBindOpticalFlowSessionImageNV = unsafe extern "system" fn(device: VkDevice, session: VkOpticalFlowSessionNV, bindingPoint: VkOpticalFlowSessionBindingPointNV, view: VkImageView, layout: VkImageLayout) -> VkResult;
pub type NonNullPFN_vkBindTensorMemoryARM = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindTensorMemoryInfoARM) -> VkResult;
pub type NonNullPFN_vkBindVideoSessionMemoryKHR = unsafe extern "system" fn(device: VkDevice, videoSession: VkVideoSessionKHR, bindSessionMemoryInfoCount: u32, pBindSessionMemoryInfos: *const VkBindVideoSessionMemoryInfoKHR) -> VkResult;
pub type NonNullPFN_vkBuildAccelerationStructuresKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: *const *const VkAccelerationStructureBuildRangeInfoKHR) -> VkResult;
pub type NonNullPFN_vkBuildMicromapsEXT = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: u32, pInfos: *const VkMicromapBuildInfoEXT) -> VkResult;
pub type NonNullPFN_vkCmdBeginConditionalRenderingEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pConditionalRenderingBegin: *const VkConditionalRenderingBeginInfoEXT);
pub type NonNullPFN_vkCmdBeginCustomResolveEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBeginCustomResolveInfo: *const VkBeginCustomResolveInfoEXT);
pub type NonNullPFN_vkCmdBeginDebugUtilsLabelEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT);
pub type NonNullPFN_vkCmdBeginPerTileExecutionQCOM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPerTileBeginInfo: *const VkPerTileBeginInfoQCOM);
pub type NonNullPFN_vkCmdBeginQuery = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, flags: VkQueryControlFlags);
pub type NonNullPFN_vkCmdBeginQueryIndexedEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, flags: VkQueryControlFlags, index: u32);
pub type NonNullPFN_vkCmdBeginRenderPass = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, contents: VkSubpassContents);
pub type NonNullPFN_vkCmdBeginRenderPass2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, pSubpassBeginInfo: *const VkSubpassBeginInfo);
pub type NonNullPFN_vkCmdBeginRenderPass2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, pSubpassBeginInfo: *const VkSubpassBeginInfo);
pub type NonNullPFN_vkCmdBeginRendering = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderingInfo: *const VkRenderingInfo);
pub type NonNullPFN_vkCmdBeginRenderingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderingInfo: *const VkRenderingInfo);
pub type NonNullPFN_vkCmdBeginTransformFeedbackEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: *const VkBuffer, pCounterBufferOffsets: *const VkDeviceSize);
pub type NonNullPFN_vkCmdBeginVideoCodingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBeginInfo: *const VkVideoBeginCodingInfoKHR);
pub type NonNullPFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo: *const VkBindDescriptorBufferEmbeddedSamplersInfoEXT);
pub type NonNullPFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32);
pub type NonNullPFN_vkCmdBindDescriptorBuffersEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, bufferCount: u32, pBindingInfos: *const VkDescriptorBufferBindingInfoEXT);
pub type NonNullPFN_vkCmdBindDescriptorSets = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: u32, descriptorSetCount: u32, pDescriptorSets: *const VkDescriptorSet, dynamicOffsetCount: u32, pDynamicOffsets: *const u32);
pub type NonNullPFN_vkCmdBindDescriptorSets2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindDescriptorSetsInfo: *const VkBindDescriptorSetsInfo);
pub type NonNullPFN_vkCmdBindDescriptorSets2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindDescriptorSetsInfo: *const VkBindDescriptorSetsInfo);
pub type NonNullPFN_vkCmdBindIndexBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType);
pub type NonNullPFN_vkCmdBindIndexBuffer2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize, indexType: VkIndexType);
pub type NonNullPFN_vkCmdBindIndexBuffer2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize, indexType: VkIndexType);
pub type NonNullPFN_vkCmdBindInvocationMaskHUAWEI = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout);
pub type NonNullPFN_vkCmdBindPipeline = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline);
pub type NonNullPFN_vkCmdBindPipelineShaderGroupNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, groupIndex: u32);
pub type NonNullPFN_vkCmdBindShadersEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stageCount: u32, pStages: *const VkShaderStageFlagBits, pShaders: *const VkShaderEXT);
pub type NonNullPFN_vkCmdBindShadingRateImageNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout);
pub type NonNullPFN_vkCmdBindTileMemoryQCOM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pTileMemoryBindInfo: *const VkTileMemoryBindInfoQCOM);
pub type NonNullPFN_vkCmdBindTransformFeedbackBuffersEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize);
pub type NonNullPFN_vkCmdBindVertexBuffers = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize);
pub type NonNullPFN_vkCmdBindVertexBuffers2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize, pStrides: *const VkDeviceSize);
pub type NonNullPFN_vkCmdBindVertexBuffers2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize, pStrides: *const VkDeviceSize);
pub type NonNullPFN_vkCmdBlitImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageBlit, filter: VkFilter);
pub type NonNullPFN_vkCmdBlitImage2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBlitImageInfo: *const VkBlitImageInfo2);
pub type NonNullPFN_vkCmdBlitImage2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBlitImageInfo: *const VkBlitImageInfo2);
pub type NonNullPFN_vkCmdBuildAccelerationStructureNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkAccelerationStructureInfoNV, instanceData: VkBuffer, instanceOffset: VkDeviceSize, update: VkBool32, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, scratch: VkBuffer, scratchOffset: VkDeviceSize);
pub type NonNullPFN_vkCmdBuildAccelerationStructuresIndirectKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, pIndirectDeviceAddresses: *const VkDeviceAddress, pIndirectStrides: *const u32, ppMaxPrimitiveCounts: *const *const u32);
pub type NonNullPFN_vkCmdBuildAccelerationStructuresKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: *const *const VkAccelerationStructureBuildRangeInfoKHR);
pub type NonNullPFN_vkCmdBuildClusterAccelerationStructureIndirectNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCommandInfos: *const VkClusterAccelerationStructureCommandsInfoNV);
pub type NonNullPFN_vkCmdBuildMicromapsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkMicromapBuildInfoEXT);
pub type NonNullPFN_vkCmdBuildPartitionedAccelerationStructuresNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBuildInfo: *const VkBuildPartitionedAccelerationStructureInfoNV);
pub type NonNullPFN_vkCmdClearAttachments = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, attachmentCount: u32, pAttachments: *const VkClearAttachment, rectCount: u32, pRects: *const VkClearRect);
pub type NonNullPFN_vkCmdClearColorImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: *const VkClearColorValue, rangeCount: u32, pRanges: *const VkImageSubresourceRange);
pub type NonNullPFN_vkCmdClearDepthStencilImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: *const VkClearDepthStencilValue, rangeCount: u32, pRanges: *const VkImageSubresourceRange);
pub type NonNullPFN_vkCmdControlVideoCodingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCodingControlInfo: *const VkVideoCodingControlInfoKHR);
pub type NonNullPFN_vkCmdConvertCooperativeVectorMatrixNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkConvertCooperativeVectorMatrixInfoNV);
pub type NonNullPFN_vkCmdCopyAccelerationStructureKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyAccelerationStructureInfoKHR);
pub type NonNullPFN_vkCmdCopyAccelerationStructureNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, mode: VkCopyAccelerationStructureModeKHR);
pub type NonNullPFN_vkCmdCopyAccelerationStructureToMemoryKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR);
pub type NonNullPFN_vkCmdCopyBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferCopy);
pub type NonNullPFN_vkCmdCopyBuffer2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyBufferInfo: *const VkCopyBufferInfo2);
pub type NonNullPFN_vkCmdCopyBuffer2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyBufferInfo: *const VkCopyBufferInfo2);
pub type NonNullPFN_vkCmdCopyBufferToImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkBufferImageCopy);
pub type NonNullPFN_vkCmdCopyBufferToImage2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: *const VkCopyBufferToImageInfo2);
pub type NonNullPFN_vkCmdCopyBufferToImage2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: *const VkCopyBufferToImageInfo2);
pub type NonNullPFN_vkCmdCopyImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageCopy);
pub type NonNullPFN_vkCmdCopyImage2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyImageInfo: *const VkCopyImageInfo2);
pub type NonNullPFN_vkCmdCopyImage2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyImageInfo: *const VkCopyImageInfo2);
pub type NonNullPFN_vkCmdCopyImageToBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferImageCopy);
pub type NonNullPFN_vkCmdCopyImageToBuffer2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: *const VkCopyImageToBufferInfo2);
pub type NonNullPFN_vkCmdCopyImageToBuffer2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: *const VkCopyImageToBufferInfo2);
pub type NonNullPFN_vkCmdCopyMemoryIndirectKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyMemoryIndirectInfo: *const VkCopyMemoryIndirectInfoKHR);
pub type NonNullPFN_vkCmdCopyMemoryIndirectNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: u32, stride: u32);
pub type NonNullPFN_vkCmdCopyMemoryToAccelerationStructureKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR);
pub type NonNullPFN_vkCmdCopyMemoryToImageIndirectKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyMemoryToImageIndirectInfo: *const VkCopyMemoryToImageIndirectInfoKHR);
pub type NonNullPFN_vkCmdCopyMemoryToImageIndirectNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: u32, stride: u32, dstImage: VkImage, dstImageLayout: VkImageLayout, pImageSubresources: *const VkImageSubresourceLayers);
pub type NonNullPFN_vkCmdCopyMemoryToMicromapEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMemoryToMicromapInfoEXT);
pub type NonNullPFN_vkCmdCopyMicromapEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMicromapInfoEXT);
pub type NonNullPFN_vkCmdCopyMicromapToMemoryEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMicromapToMemoryInfoEXT);
pub type NonNullPFN_vkCmdCopyQueryPoolResults = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags);
pub type NonNullPFN_vkCmdCopyTensorARM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyTensorInfo: *const VkCopyTensorInfoARM);
pub type NonNullPFN_vkCmdCuLaunchKernelNVX = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLaunchInfo: *const VkCuLaunchInfoNVX);
pub type NonNullPFN_vkCmdDebugMarkerBeginEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT);
pub type NonNullPFN_vkCmdDebugMarkerEndEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
pub type NonNullPFN_vkCmdDebugMarkerInsertEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT);
pub type NonNullPFN_vkCmdDecodeVideoKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDecodeInfo: *const VkVideoDecodeInfoKHR);
pub type NonNullPFN_vkCmdDecompressMemoryEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDecompressMemoryInfoEXT: *const VkDecompressMemoryInfoEXT);
pub type NonNullPFN_vkCmdDecompressMemoryIndirectCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, decompressionMethod: VkMemoryDecompressionMethodFlagsEXT, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, maxDecompressionCount: u32, stride: u32);
pub type NonNullPFN_vkCmdDecompressMemoryIndirectCountNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, stride: u32);
pub type NonNullPFN_vkCmdDecompressMemoryNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, decompressRegionCount: u32, pDecompressMemoryRegions: *const VkDecompressMemoryRegionNV);
pub type NonNullPFN_vkCmdDispatch = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
pub type NonNullPFN_vkCmdDispatchBase = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
pub type NonNullPFN_vkCmdDispatchBaseKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
pub type NonNullPFN_vkCmdDispatchDataGraphARM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, session: VkDataGraphPipelineSessionARM, pInfo: *const VkDataGraphPipelineDispatchInfoARM);
pub type NonNullPFN_vkCmdDispatchIndirect = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize);
pub type NonNullPFN_vkCmdDispatchTileQCOM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDispatchTileInfo: *const VkDispatchTileInfoQCOM);
pub type NonNullPFN_vkCmdDraw = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32);
pub type NonNullPFN_vkCmdDrawClusterHUAWEI = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
pub type NonNullPFN_vkCmdDrawClusterIndirectHUAWEI = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize);
pub type NonNullPFN_vkCmdDrawIndexed = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, indexCount: u32, instanceCount: u32, firstIndex: u32, vertexOffset: i32, firstInstance: u32);
pub type NonNullPFN_vkCmdDrawIndexedIndirect = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
pub type NonNullPFN_vkCmdDrawIndexedIndirectCount = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
pub type NonNullPFN_vkCmdDrawIndexedIndirectCountAMD = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
pub type NonNullPFN_vkCmdDrawIndexedIndirectCountKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
pub type NonNullPFN_vkCmdDrawIndirect = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
pub type NonNullPFN_vkCmdDrawIndirectByteCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, instanceCount: u32, firstInstance: u32, counterBuffer: VkBuffer, counterBufferOffset: VkDeviceSize, counterOffset: u32, vertexStride: u32);
pub type NonNullPFN_vkCmdDrawIndirectCount = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
pub type NonNullPFN_vkCmdDrawIndirectCountAMD = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
pub type NonNullPFN_vkCmdDrawIndirectCountKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
pub type NonNullPFN_vkCmdDrawMeshTasksEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
pub type NonNullPFN_vkCmdDrawMeshTasksIndirectCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
pub type NonNullPFN_vkCmdDrawMeshTasksIndirectCountNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
pub type NonNullPFN_vkCmdDrawMeshTasksIndirectEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
pub type NonNullPFN_vkCmdDrawMeshTasksIndirectNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
pub type NonNullPFN_vkCmdDrawMeshTasksNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, taskCount: u32, firstTask: u32);
pub type NonNullPFN_vkCmdDrawMultiEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, drawCount: u32, pVertexInfo: *const VkMultiDrawInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32);
pub type NonNullPFN_vkCmdDrawMultiIndexedEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, drawCount: u32, pIndexInfo: *const VkMultiDrawIndexedInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32, pVertexOffset: *const i32);
pub type NonNullPFN_vkCmdEncodeVideoKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pEncodeInfo: *const VkVideoEncodeInfoKHR);
pub type NonNullPFN_vkCmdEndConditionalRenderingEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
pub type NonNullPFN_vkCmdEndDebugUtilsLabelEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
pub type NonNullPFN_vkCmdEndPerTileExecutionQCOM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPerTileEndInfo: *const VkPerTileEndInfoQCOM);
pub type NonNullPFN_vkCmdEndQuery = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32);
pub type NonNullPFN_vkCmdEndQueryIndexedEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, index: u32);
pub type NonNullPFN_vkCmdEndRenderPass = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
pub type NonNullPFN_vkCmdEndRenderPass2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSubpassEndInfo: *const VkSubpassEndInfo);
pub type NonNullPFN_vkCmdEndRenderPass2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSubpassEndInfo: *const VkSubpassEndInfo);
pub type NonNullPFN_vkCmdEndRendering = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
pub type NonNullPFN_vkCmdEndRendering2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderingEndInfo: *const VkRenderingEndInfoKHR);
pub type NonNullPFN_vkCmdEndRendering2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderingEndInfo: *const VkRenderingEndInfoKHR);
pub type NonNullPFN_vkCmdEndRenderingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
pub type NonNullPFN_vkCmdEndTransformFeedbackEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: *const VkBuffer, pCounterBufferOffsets: *const VkDeviceSize);
pub type NonNullPFN_vkCmdEndVideoCodingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pEndCodingInfo: *const VkVideoEndCodingInfoKHR);
pub type NonNullPFN_vkCmdExecuteCommands = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, commandBufferCount: u32, pCommandBuffers: *const VkCommandBuffer);
pub type NonNullPFN_vkCmdExecuteGeneratedCommandsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoEXT);
pub type NonNullPFN_vkCmdExecuteGeneratedCommandsNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV);
pub type NonNullPFN_vkCmdFillBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: u32);
pub type NonNullPFN_vkCmdInsertDebugUtilsLabelEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT);
pub type NonNullPFN_vkCmdNextSubpass = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, contents: VkSubpassContents);
pub type NonNullPFN_vkCmdNextSubpass2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: *const VkSubpassBeginInfo, pSubpassEndInfo: *const VkSubpassEndInfo);
pub type NonNullPFN_vkCmdNextSubpass2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: *const VkSubpassBeginInfo, pSubpassEndInfo: *const VkSubpassEndInfo);
pub type NonNullPFN_vkCmdOpticalFlowExecuteNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, session: VkOpticalFlowSessionNV, pExecuteInfo: *const VkOpticalFlowExecuteInfoNV);
pub type NonNullPFN_vkCmdPipelineBarrier = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: u32, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: *const VkImageMemoryBarrier);
pub type NonNullPFN_vkCmdPipelineBarrier2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfo);
pub type NonNullPFN_vkCmdPipelineBarrier2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfo);
pub type NonNullPFN_vkCmdPreprocessGeneratedCommandsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoEXT, stateCommandBuffer: VkCommandBuffer);
pub type NonNullPFN_vkCmdPreprocessGeneratedCommandsNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV);
pub type NonNullPFN_vkCmdPushConstants = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: u32, size: u32, pValues: *const c_void);
pub type NonNullPFN_vkCmdPushConstants2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushConstantsInfo: *const VkPushConstantsInfo);
pub type NonNullPFN_vkCmdPushConstants2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushConstantsInfo: *const VkPushConstantsInfo);
pub type NonNullPFN_vkCmdPushDescriptorSet = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet);
pub type NonNullPFN_vkCmdPushDescriptorSet2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDescriptorSetInfo: *const VkPushDescriptorSetInfo);
pub type NonNullPFN_vkCmdPushDescriptorSet2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDescriptorSetInfo: *const VkPushDescriptorSetInfo);
pub type NonNullPFN_vkCmdPushDescriptorSetKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet);
pub type NonNullPFN_vkCmdPushDescriptorSetWithTemplate = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: u32, pData: *const c_void);
pub type NonNullPFN_vkCmdPushDescriptorSetWithTemplate2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDescriptorSetWithTemplateInfo: *const VkPushDescriptorSetWithTemplateInfo);
pub type NonNullPFN_vkCmdPushDescriptorSetWithTemplate2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDescriptorSetWithTemplateInfo: *const VkPushDescriptorSetWithTemplateInfo);
pub type NonNullPFN_vkCmdPushDescriptorSetWithTemplateKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: u32, pData: *const c_void);
pub type NonNullPFN_vkCmdResetEvent = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags);
pub type NonNullPFN_vkCmdResetEvent2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2);
pub type NonNullPFN_vkCmdResetEvent2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2);
pub type NonNullPFN_vkCmdResetQueryPool = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);
pub type NonNullPFN_vkCmdResolveImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageResolve);
pub type NonNullPFN_vkCmdResolveImage2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pResolveImageInfo: *const VkResolveImageInfo2);
pub type NonNullPFN_vkCmdResolveImage2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pResolveImageInfo: *const VkResolveImageInfo2);
pub type NonNullPFN_vkCmdSetAlphaToCoverageEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, alphaToCoverageEnable: VkBool32);
pub type NonNullPFN_vkCmdSetAlphaToOneEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, alphaToOneEnable: VkBool32);
pub type NonNullPFN_vkCmdSetAttachmentFeedbackLoopEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, aspectMask: VkImageAspectFlags);
pub type NonNullPFN_vkCmdSetBlendConstants = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, blendConstants: *const f32);
pub type NonNullPFN_vkCmdSetCheckpointNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCheckpointMarker: *const c_void);
pub type NonNullPFN_vkCmdSetCoarseSampleOrderNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: u32, pCustomSampleOrders: *const VkCoarseSampleOrderCustomNV);
pub type NonNullPFN_vkCmdSetColorBlendAdvancedEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendAdvanced: *const VkColorBlendAdvancedEXT);
pub type NonNullPFN_vkCmdSetColorBlendEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendEnables: *const VkBool32);
pub type NonNullPFN_vkCmdSetColorBlendEquationEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendEquations: *const VkColorBlendEquationEXT);
pub type NonNullPFN_vkCmdSetColorWriteEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, attachmentCount: u32, pColorWriteEnables: *const VkBool32);
pub type NonNullPFN_vkCmdSetColorWriteMaskEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorWriteMasks: *const VkColorComponentFlags);
pub type NonNullPFN_vkCmdSetComputeOccupancyPriorityNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pParameters: *const VkComputeOccupancyPriorityParametersNV);
pub type NonNullPFN_vkCmdSetConservativeRasterizationModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, conservativeRasterizationMode: VkConservativeRasterizationModeEXT);
pub type NonNullPFN_vkCmdSetCoverageModulationModeNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageModulationMode: VkCoverageModulationModeNV);
pub type NonNullPFN_vkCmdSetCoverageModulationTableEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageModulationTableEnable: VkBool32);
pub type NonNullPFN_vkCmdSetCoverageModulationTableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageModulationTableCount: u32, pCoverageModulationTable: *const f32);
pub type NonNullPFN_vkCmdSetCoverageReductionModeNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageReductionMode: VkCoverageReductionModeNV);
pub type NonNullPFN_vkCmdSetCoverageToColorEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageToColorEnable: VkBool32);
pub type NonNullPFN_vkCmdSetCoverageToColorLocationNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageToColorLocation: u32);
pub type NonNullPFN_vkCmdSetCullMode = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags);
pub type NonNullPFN_vkCmdSetCullModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags);
pub type NonNullPFN_vkCmdSetDepthBias = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: f32, depthBiasClamp: f32, depthBiasSlopeFactor: f32);
pub type NonNullPFN_vkCmdSetDepthBias2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDepthBiasInfo: *const VkDepthBiasInfoEXT);
pub type NonNullPFN_vkCmdSetDepthBiasEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32);
pub type NonNullPFN_vkCmdSetDepthBiasEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32);
pub type NonNullPFN_vkCmdSetDepthBounds = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, minDepthBounds: f32, maxDepthBounds: f32);
pub type NonNullPFN_vkCmdSetDepthBoundsTestEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32);
pub type NonNullPFN_vkCmdSetDepthBoundsTestEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32);
pub type NonNullPFN_vkCmdSetDepthClampEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthClampEnable: VkBool32);
pub type NonNullPFN_vkCmdSetDepthClampRangeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthClampMode: VkDepthClampModeEXT, pDepthClampRange: *const VkDepthClampRangeEXT);
pub type NonNullPFN_vkCmdSetDepthClipEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthClipEnable: VkBool32);
pub type NonNullPFN_vkCmdSetDepthClipNegativeOneToOneEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, negativeOneToOne: VkBool32);
pub type NonNullPFN_vkCmdSetDepthCompareOp = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp);
pub type NonNullPFN_vkCmdSetDepthCompareOpEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp);
pub type NonNullPFN_vkCmdSetDepthTestEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32);
pub type NonNullPFN_vkCmdSetDepthTestEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32);
pub type NonNullPFN_vkCmdSetDepthWriteEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32);
pub type NonNullPFN_vkCmdSetDepthWriteEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32);
pub type NonNullPFN_vkCmdSetDescriptorBufferOffsets2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSetDescriptorBufferOffsetsInfo: *const VkSetDescriptorBufferOffsetsInfoEXT);
pub type NonNullPFN_vkCmdSetDescriptorBufferOffsetsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: u32, setCount: u32, pBufferIndices: *const u32, pOffsets: *const VkDeviceSize);
pub type NonNullPFN_vkCmdSetDeviceMask = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, deviceMask: u32);
pub type NonNullPFN_vkCmdSetDeviceMaskKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, deviceMask: u32);
pub type NonNullPFN_vkCmdSetDiscardRectangleEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstDiscardRectangle: u32, discardRectangleCount: u32, pDiscardRectangles: *const VkRect2D);
pub type NonNullPFN_vkCmdSetDiscardRectangleEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, discardRectangleEnable: VkBool32);
pub type NonNullPFN_vkCmdSetDiscardRectangleModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, discardRectangleMode: VkDiscardRectangleModeEXT);
pub type NonNullPFN_vkCmdSetEvent = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags);
pub type NonNullPFN_vkCmdSetEvent2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfo);
pub type NonNullPFN_vkCmdSetEvent2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfo);
pub type NonNullPFN_vkCmdSetExclusiveScissorEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissorEnables: *const VkBool32);
pub type NonNullPFN_vkCmdSetExclusiveScissorNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissors: *const VkRect2D);
pub type NonNullPFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, extraPrimitiveOverestimationSize: f32);
pub type NonNullPFN_vkCmdSetFragmentShadingRateEnumNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, shadingRate: VkFragmentShadingRateNV, combinerOps: *const VkFragmentShadingRateCombinerOpKHR);
pub type NonNullPFN_vkCmdSetFragmentShadingRateKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pFragmentSize: *const VkExtent2D, combinerOps: *const VkFragmentShadingRateCombinerOpKHR);
pub type NonNullPFN_vkCmdSetFrontFace = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace);
pub type NonNullPFN_vkCmdSetFrontFaceEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace);
pub type NonNullPFN_vkCmdSetLineRasterizationModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineRasterizationMode: VkLineRasterizationModeEXT);
pub type NonNullPFN_vkCmdSetLineStipple = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
pub type NonNullPFN_vkCmdSetLineStippleEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
pub type NonNullPFN_vkCmdSetLineStippleEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stippledLineEnable: VkBool32);
pub type NonNullPFN_vkCmdSetLineStippleKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
pub type NonNullPFN_vkCmdSetLineWidth = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineWidth: f32);
pub type NonNullPFN_vkCmdSetLogicOpEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, logicOp: VkLogicOp);
pub type NonNullPFN_vkCmdSetLogicOpEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, logicOpEnable: VkBool32);
pub type NonNullPFN_vkCmdSetPatchControlPointsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, patchControlPoints: u32);
pub type NonNullPFN_vkCmdSetPerformanceMarkerINTEL = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkPerformanceMarkerInfoINTEL) -> VkResult;
pub type NonNullPFN_vkCmdSetPerformanceOverrideINTEL = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pOverrideInfo: *const VkPerformanceOverrideInfoINTEL) -> VkResult;
pub type NonNullPFN_vkCmdSetPerformanceStreamMarkerINTEL = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkPerformanceStreamMarkerInfoINTEL) -> VkResult;
pub type NonNullPFN_vkCmdSetPolygonModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, polygonMode: VkPolygonMode);
pub type NonNullPFN_vkCmdSetPrimitiveRestartEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32);
pub type NonNullPFN_vkCmdSetPrimitiveRestartEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32);
pub type NonNullPFN_vkCmdSetPrimitiveTopology = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology);
pub type NonNullPFN_vkCmdSetPrimitiveTopologyEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology);
pub type NonNullPFN_vkCmdSetProvokingVertexModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, provokingVertexMode: VkProvokingVertexModeEXT);
pub type NonNullPFN_vkCmdSetRasterizationSamplesEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, rasterizationSamples: VkSampleCountFlagBits);
pub type NonNullPFN_vkCmdSetRasterizationStreamEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, rasterizationStream: u32);
pub type NonNullPFN_vkCmdSetRasterizerDiscardEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32);
pub type NonNullPFN_vkCmdSetRasterizerDiscardEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32);
pub type NonNullPFN_vkCmdSetRayTracingPipelineStackSizeKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineStackSize: u32);
pub type NonNullPFN_vkCmdSetRenderingAttachmentLocations = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLocationInfo: *const VkRenderingAttachmentLocationInfo);
pub type NonNullPFN_vkCmdSetRenderingAttachmentLocationsKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLocationInfo: *const VkRenderingAttachmentLocationInfo);
pub type NonNullPFN_vkCmdSetRenderingInputAttachmentIndices = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInputAttachmentIndexInfo: *const VkRenderingInputAttachmentIndexInfo);
pub type NonNullPFN_vkCmdSetRenderingInputAttachmentIndicesKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInputAttachmentIndexInfo: *const VkRenderingInputAttachmentIndexInfo);
pub type NonNullPFN_vkCmdSetRepresentativeFragmentTestEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, representativeFragmentTestEnable: VkBool32);
pub type NonNullPFN_vkCmdSetSampleLocationsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSampleLocationsInfo: *const VkSampleLocationsInfoEXT);
pub type NonNullPFN_vkCmdSetSampleLocationsEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, sampleLocationsEnable: VkBool32);
pub type NonNullPFN_vkCmdSetSampleMaskEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, samples: VkSampleCountFlagBits, pSampleMask: *const VkSampleMask);
pub type NonNullPFN_vkCmdSetScissor = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstScissor: u32, scissorCount: u32, pScissors: *const VkRect2D);
pub type NonNullPFN_vkCmdSetScissorWithCount = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, scissorCount: u32, pScissors: *const VkRect2D);
pub type NonNullPFN_vkCmdSetScissorWithCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, scissorCount: u32, pScissors: *const VkRect2D);
pub type NonNullPFN_vkCmdSetShadingRateImageEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, shadingRateImageEnable: VkBool32);
pub type NonNullPFN_vkCmdSetStencilCompareMask = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: u32);
pub type NonNullPFN_vkCmdSetStencilOp = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp);
pub type NonNullPFN_vkCmdSetStencilOpEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp);
pub type NonNullPFN_vkCmdSetStencilReference = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: u32);
pub type NonNullPFN_vkCmdSetStencilTestEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32);
pub type NonNullPFN_vkCmdSetStencilTestEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32);
pub type NonNullPFN_vkCmdSetStencilWriteMask = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: u32);
pub type NonNullPFN_vkCmdSetTessellationDomainOriginEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, domainOrigin: VkTessellationDomainOrigin);
pub type NonNullPFN_vkCmdSetVertexInputEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, vertexBindingDescriptionCount: u32, pVertexBindingDescriptions: *const VkVertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: u32, pVertexAttributeDescriptions: *const VkVertexInputAttributeDescription2EXT);
pub type NonNullPFN_vkCmdSetViewport = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewports: *const VkViewport);
pub type NonNullPFN_vkCmdSetViewportShadingRatePaletteNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pShadingRatePalettes: *const VkShadingRatePaletteNV);
pub type NonNullPFN_vkCmdSetViewportSwizzleNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewportSwizzles: *const VkViewportSwizzleNV);
pub type NonNullPFN_vkCmdSetViewportWScalingEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, viewportWScalingEnable: VkBool32);
pub type NonNullPFN_vkCmdSetViewportWScalingNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewportWScalings: *const VkViewportWScalingNV);
pub type NonNullPFN_vkCmdSetViewportWithCount = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, viewportCount: u32, pViewports: *const VkViewport);
pub type NonNullPFN_vkCmdSetViewportWithCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, viewportCount: u32, pViewports: *const VkViewport);
pub type NonNullPFN_vkCmdSubpassShadingHUAWEI = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
pub type NonNullPFN_vkCmdTraceRaysIndirect2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, indirectDeviceAddress: VkDeviceAddress);
pub type NonNullPFN_vkCmdTraceRaysIndirectKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, indirectDeviceAddress: VkDeviceAddress);
pub type NonNullPFN_vkCmdTraceRaysKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, width: u32, height: u32, depth: u32);
pub type NonNullPFN_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: u32, height: u32, depth: u32);
pub type NonNullPFN_vkCmdUpdateBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: *const c_void);
pub type NonNullPFN_vkCmdUpdatePipelineIndirectBufferNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline);
pub type NonNullPFN_vkCmdWaitEvents = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, memoryBarrierCount: u32, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: *const VkImageMemoryBarrier);
pub type NonNullPFN_vkCmdWaitEvents2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfo);
pub type NonNullPFN_vkCmdWaitEvents2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfo);
pub type NonNullPFN_vkCmdWriteAccelerationStructuresPropertiesKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureKHR, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);
pub type NonNullPFN_vkCmdWriteAccelerationStructuresPropertiesNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureNV, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);
pub type NonNullPFN_vkCmdWriteBufferMarker2AMD = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: u32);
pub type NonNullPFN_vkCmdWriteBufferMarkerAMD = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: u32);
pub type NonNullPFN_vkCmdWriteMicromapsPropertiesEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, micromapCount: u32, pMicromaps: *const VkMicromapEXT, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);
pub type NonNullPFN_vkCmdWriteTimestamp = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, queryPool: VkQueryPool, query: u32);
pub type NonNullPFN_vkCmdWriteTimestamp2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: u32);
pub type NonNullPFN_vkCmdWriteTimestamp2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: u32);
pub type NonNullPFN_vkCompileDeferredNV = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, shader: u32) -> VkResult;
pub type NonNullPFN_vkConvertCooperativeVectorMatrixNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkConvertCooperativeVectorMatrixInfoNV) -> VkResult;
pub type NonNullPFN_vkCopyAccelerationStructureKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyAccelerationStructureInfoKHR) -> VkResult;
pub type NonNullPFN_vkCopyAccelerationStructureToMemoryKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR) -> VkResult;
pub type NonNullPFN_vkCopyImageToImage = unsafe extern "system" fn(device: VkDevice, pCopyImageToImageInfo: *const VkCopyImageToImageInfo) -> VkResult;
pub type NonNullPFN_vkCopyImageToImageEXT = unsafe extern "system" fn(device: VkDevice, pCopyImageToImageInfo: *const VkCopyImageToImageInfo) -> VkResult;
pub type NonNullPFN_vkCopyImageToMemory = unsafe extern "system" fn(device: VkDevice, pCopyImageToMemoryInfo: *const VkCopyImageToMemoryInfo) -> VkResult;
pub type NonNullPFN_vkCopyImageToMemoryEXT = unsafe extern "system" fn(device: VkDevice, pCopyImageToMemoryInfo: *const VkCopyImageToMemoryInfo) -> VkResult;
pub type NonNullPFN_vkCopyMemoryToAccelerationStructureKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR) -> VkResult;
pub type NonNullPFN_vkCopyMemoryToImage = unsafe extern "system" fn(device: VkDevice, pCopyMemoryToImageInfo: *const VkCopyMemoryToImageInfo) -> VkResult;
pub type NonNullPFN_vkCopyMemoryToImageEXT = unsafe extern "system" fn(device: VkDevice, pCopyMemoryToImageInfo: *const VkCopyMemoryToImageInfo) -> VkResult;
pub type NonNullPFN_vkCopyMemoryToMicromapEXT = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMemoryToMicromapInfoEXT) -> VkResult;
pub type NonNullPFN_vkCopyMicromapEXT = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMicromapInfoEXT) -> VkResult;
pub type NonNullPFN_vkCopyMicromapToMemoryEXT = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMicromapToMemoryInfoEXT) -> VkResult;
pub type NonNullPFN_vkCreateAccelerationStructureKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkAccelerationStructureCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pAccelerationStructure: *mut VkAccelerationStructureKHR) -> VkResult;
pub type NonNullPFN_vkCreateAccelerationStructureNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkAccelerationStructureCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pAccelerationStructure: *mut VkAccelerationStructureNV) -> VkResult;
pub type NonNullPFN_vkCreateBuffer = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkBufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pBuffer: *mut VkBuffer) -> VkResult;
pub type NonNullPFN_vkCreateBufferView = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkBufferViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkBufferView) -> VkResult;
pub type NonNullPFN_vkCreateCommandPool = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkCommandPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pCommandPool: *mut VkCommandPool) -> VkResult;
pub type NonNullPFN_vkCreateComputePipelines = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkComputePipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
pub type NonNullPFN_vkCreateCuFunctionNVX = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkCuFunctionCreateInfoNVX, pAllocator: *const VkAllocationCallbacks, pFunction: *mut VkCuFunctionNVX) -> VkResult;
pub type NonNullPFN_vkCreateCuModuleNVX = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkCuModuleCreateInfoNVX, pAllocator: *const VkAllocationCallbacks, pModule: *mut VkCuModuleNVX) -> VkResult;
pub type NonNullPFN_vkCreateDataGraphPipelineSessionARM = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDataGraphPipelineSessionCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pSession: *mut VkDataGraphPipelineSessionARM) -> VkResult;
pub type NonNullPFN_vkCreateDataGraphPipelinesARM = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkDataGraphPipelineCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
pub type NonNullPFN_vkCreateDebugReportCallbackEXT = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkDebugReportCallbackCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pCallback: *mut VkDebugReportCallbackEXT) -> VkResult;
pub type NonNullPFN_vkCreateDebugUtilsMessengerEXT = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkDebugUtilsMessengerCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pMessenger: *mut VkDebugUtilsMessengerEXT) -> VkResult;
pub type NonNullPFN_vkCreateDeferredOperationKHR = unsafe extern "system" fn(device: VkDevice, pAllocator: *const VkAllocationCallbacks, pDeferredOperation: *mut VkDeferredOperationKHR) -> VkResult;
pub type NonNullPFN_vkCreateDescriptorPool = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorPool: *mut VkDescriptorPool) -> VkResult;
pub type NonNullPFN_vkCreateDescriptorSetLayout = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pSetLayout: *mut VkDescriptorSetLayout) -> VkResult;
pub type NonNullPFN_vkCreateDescriptorUpdateTemplate = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate) -> VkResult;
pub type NonNullPFN_vkCreateDescriptorUpdateTemplateKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate) -> VkResult;
pub type NonNullPFN_vkCreateDevice = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pCreateInfo: *const VkDeviceCreateInfo, pAllocator: *const VkAllocationCallbacks, pDevice: *mut VkDevice) -> VkResult;
pub type NonNullPFN_vkCreateDisplayModeKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: *const VkDisplayModeCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pMode: *mut VkDisplayModeKHR) -> VkResult;
pub type NonNullPFN_vkCreateDisplayPlaneSurfaceKHR = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkDisplaySurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
pub type NonNullPFN_vkCreateEvent = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkEventCreateInfo, pAllocator: *const VkAllocationCallbacks, pEvent: *mut VkEvent) -> VkResult;
pub type NonNullPFN_vkCreateExternalComputeQueueNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkExternalComputeQueueCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pExternalQueue: *mut VkExternalComputeQueueNV) -> VkResult;
pub type NonNullPFN_vkCreateFence = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkFenceCreateInfo, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;
pub type NonNullPFN_vkCreateFramebuffer = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkFramebufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pFramebuffer: *mut VkFramebuffer) -> VkResult;
pub type NonNullPFN_vkCreateGraphicsPipelines = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkGraphicsPipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
pub type NonNullPFN_vkCreateHeadlessSurfaceEXT = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkHeadlessSurfaceCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
pub type NonNullPFN_vkCreateImage = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkImageCreateInfo, pAllocator: *const VkAllocationCallbacks, pImage: *mut VkImage) -> VkResult;
pub type NonNullPFN_vkCreateImageView = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkImageViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkImageView) -> VkResult;
pub type NonNullPFN_vkCreateIndirectCommandsLayoutEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutEXT) -> VkResult;
pub type NonNullPFN_vkCreateIndirectCommandsLayoutNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutNV) -> VkResult;
pub type NonNullPFN_vkCreateIndirectExecutionSetEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkIndirectExecutionSetCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pIndirectExecutionSet: *mut VkIndirectExecutionSetEXT) -> VkResult;
pub type NonNullPFN_vkCreateInstance = unsafe extern "system" fn(pCreateInfo: *const VkInstanceCreateInfo, pAllocator: *const VkAllocationCallbacks, pInstance: *mut VkInstance) -> VkResult;
pub type NonNullPFN_vkCreateMicromapEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkMicromapCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pMicromap: *mut VkMicromapEXT) -> VkResult;
pub type NonNullPFN_vkCreateOpticalFlowSessionNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkOpticalFlowSessionCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pSession: *mut VkOpticalFlowSessionNV) -> VkResult;
pub type NonNullPFN_vkCreatePipelineBinariesKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPipelineBinaryCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pBinaries: *mut VkPipelineBinaryHandlesInfoKHR) -> VkResult;
pub type NonNullPFN_vkCreatePipelineCache = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPipelineCacheCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineCache: *mut VkPipelineCache) -> VkResult;
pub type NonNullPFN_vkCreatePipelineLayout = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPipelineLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineLayout: *mut VkPipelineLayout) -> VkResult;
pub type NonNullPFN_vkCreatePrivateDataSlot = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPrivateDataSlotCreateInfo, pAllocator: *const VkAllocationCallbacks, pPrivateDataSlot: *mut VkPrivateDataSlot) -> VkResult;
pub type NonNullPFN_vkCreatePrivateDataSlotEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPrivateDataSlotCreateInfo, pAllocator: *const VkAllocationCallbacks, pPrivateDataSlot: *mut VkPrivateDataSlot) -> VkResult;
pub type NonNullPFN_vkCreateQueryPool = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkQueryPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pQueryPool: *mut VkQueryPool) -> VkResult;
pub type NonNullPFN_vkCreateRayTracingPipelinesKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkRayTracingPipelineCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
pub type NonNullPFN_vkCreateRayTracingPipelinesNV = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkRayTracingPipelineCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
pub type NonNullPFN_vkCreateRenderPass = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;
pub type NonNullPFN_vkCreateRenderPass2 = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo2, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;
pub type NonNullPFN_vkCreateRenderPass2KHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo2, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;
pub type NonNullPFN_vkCreateSampler = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSamplerCreateInfo, pAllocator: *const VkAllocationCallbacks, pSampler: *mut VkSampler) -> VkResult;
pub type NonNullPFN_vkCreateSamplerYcbcrConversion = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversion) -> VkResult;
pub type NonNullPFN_vkCreateSamplerYcbcrConversionKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversion) -> VkResult;
pub type NonNullPFN_vkCreateSemaphore = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSemaphoreCreateInfo, pAllocator: *const VkAllocationCallbacks, pSemaphore: *mut VkSemaphore) -> VkResult;
pub type NonNullPFN_vkCreateShaderModule = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pAllocator: *const VkAllocationCallbacks, pShaderModule: *mut VkShaderModule) -> VkResult;
pub type NonNullPFN_vkCreateShadersEXT = unsafe extern "system" fn(device: VkDevice, createInfoCount: u32, pCreateInfos: *const VkShaderCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pShaders: *mut VkShaderEXT) -> VkResult;
pub type NonNullPFN_vkCreateSharedSwapchainsKHR = unsafe extern "system" fn(device: VkDevice, swapchainCount: u32, pCreateInfos: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchains: *mut VkSwapchainKHR) -> VkResult;
pub type NonNullPFN_vkCreateSwapchainKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchain: *mut VkSwapchainKHR) -> VkResult;
pub type NonNullPFN_vkCreateTensorARM = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkTensorCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pTensor: *mut VkTensorARM) -> VkResult;
pub type NonNullPFN_vkCreateTensorViewARM = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkTensorViewCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pView: *mut VkTensorViewARM) -> VkResult;
pub type NonNullPFN_vkCreateValidationCacheEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkValidationCacheCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pValidationCache: *mut VkValidationCacheEXT) -> VkResult;
pub type NonNullPFN_vkCreateVideoSessionKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkVideoSessionCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pVideoSession: *mut VkVideoSessionKHR) -> VkResult;
pub type NonNullPFN_vkCreateVideoSessionParametersKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkVideoSessionParametersCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pVideoSessionParameters: *mut VkVideoSessionParametersKHR) -> VkResult;
pub type NonNullPFN_vkDebugMarkerSetObjectNameEXT = unsafe extern "system" fn(device: VkDevice, pNameInfo: *const VkDebugMarkerObjectNameInfoEXT) -> VkResult;
pub type NonNullPFN_vkDebugMarkerSetObjectTagEXT = unsafe extern "system" fn(device: VkDevice, pTagInfo: *const VkDebugMarkerObjectTagInfoEXT) -> VkResult;
pub type NonNullPFN_vkDebugReportCallbackEXT = unsafe extern "system" fn(flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, object: u64, location: usize, messageCode: i32, pLayerPrefix: *const c_char, pMessage: *const c_char, pUserData: *mut c_void) -> VkBool32;
pub type NonNullPFN_vkDebugReportMessageEXT = unsafe extern "system" fn(instance: VkInstance, flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, object: u64, location: usize, messageCode: i32, pLayerPrefix: *const c_char, pMessage: *const c_char);
pub type NonNullPFN_vkDebugUtilsMessengerCallbackEXT = unsafe extern "system" fn(messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: *const VkDebugUtilsMessengerCallbackDataEXT, pUserData: *mut c_void) -> VkBool32;
pub type NonNullPFN_vkDeferredOperationJoinKHR = unsafe extern "system" fn(device: VkDevice, operation: VkDeferredOperationKHR) -> VkResult;
pub type NonNullPFN_vkDestroyAccelerationStructureKHR = unsafe extern "system" fn(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyAccelerationStructureNV = unsafe extern "system" fn(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyBuffer = unsafe extern "system" fn(device: VkDevice, buffer: VkBuffer, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyBufferView = unsafe extern "system" fn(device: VkDevice, bufferView: VkBufferView, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyCommandPool = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyCuFunctionNVX = unsafe extern "system" fn(device: VkDevice, function: VkCuFunctionNVX, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyCuModuleNVX = unsafe extern "system" fn(device: VkDevice, module: VkCuModuleNVX, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyDataGraphPipelineSessionARM = unsafe extern "system" fn(device: VkDevice, session: VkDataGraphPipelineSessionARM, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyDebugReportCallbackEXT = unsafe extern "system" fn(instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyDebugUtilsMessengerEXT = unsafe extern "system" fn(instance: VkInstance, messenger: VkDebugUtilsMessengerEXT, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyDeferredOperationKHR = unsafe extern "system" fn(device: VkDevice, operation: VkDeferredOperationKHR, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyDescriptorPool = unsafe extern "system" fn(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyDescriptorSetLayout = unsafe extern "system" fn(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyDescriptorUpdateTemplate = unsafe extern "system" fn(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyDescriptorUpdateTemplateKHR = unsafe extern "system" fn(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyDevice = unsafe extern "system" fn(device: VkDevice, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyEvent = unsafe extern "system" fn(device: VkDevice, event: VkEvent, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyExternalComputeQueueNV = unsafe extern "system" fn(device: VkDevice, externalQueue: VkExternalComputeQueueNV, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyFence = unsafe extern "system" fn(device: VkDevice, fence: VkFence, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyFramebuffer = unsafe extern "system" fn(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyImage = unsafe extern "system" fn(device: VkDevice, image: VkImage, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyImageView = unsafe extern "system" fn(device: VkDevice, imageView: VkImageView, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyIndirectCommandsLayoutEXT = unsafe extern "system" fn(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutEXT, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyIndirectCommandsLayoutNV = unsafe extern "system" fn(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutNV, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyIndirectExecutionSetEXT = unsafe extern "system" fn(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyInstance = unsafe extern "system" fn(instance: VkInstance, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyMicromapEXT = unsafe extern "system" fn(device: VkDevice, micromap: VkMicromapEXT, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyOpticalFlowSessionNV = unsafe extern "system" fn(device: VkDevice, session: VkOpticalFlowSessionNV, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyPipeline = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyPipelineBinaryKHR = unsafe extern "system" fn(device: VkDevice, pipelineBinary: VkPipelineBinaryKHR, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyPipelineCache = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyPipelineLayout = unsafe extern "system" fn(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyPrivateDataSlot = unsafe extern "system" fn(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyPrivateDataSlotEXT = unsafe extern "system" fn(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyQueryPool = unsafe extern "system" fn(device: VkDevice, queryPool: VkQueryPool, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyRenderPass = unsafe extern "system" fn(device: VkDevice, renderPass: VkRenderPass, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroySampler = unsafe extern "system" fn(device: VkDevice, sampler: VkSampler, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroySamplerYcbcrConversion = unsafe extern "system" fn(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroySamplerYcbcrConversionKHR = unsafe extern "system" fn(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroySemaphore = unsafe extern "system" fn(device: VkDevice, semaphore: VkSemaphore, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyShaderEXT = unsafe extern "system" fn(device: VkDevice, shader: VkShaderEXT, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyShaderModule = unsafe extern "system" fn(device: VkDevice, shaderModule: VkShaderModule, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroySurfaceKHR = unsafe extern "system" fn(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroySwapchainKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyTensorARM = unsafe extern "system" fn(device: VkDevice, tensor: VkTensorARM, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyTensorViewARM = unsafe extern "system" fn(device: VkDevice, tensorView: VkTensorViewARM, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyValidationCacheEXT = unsafe extern "system" fn(device: VkDevice, validationCache: VkValidationCacheEXT, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyVideoSessionKHR = unsafe extern "system" fn(device: VkDevice, videoSession: VkVideoSessionKHR, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDestroyVideoSessionParametersKHR = unsafe extern "system" fn(device: VkDevice, videoSessionParameters: VkVideoSessionParametersKHR, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkDeviceMemoryReportCallbackEXT = unsafe extern "system" fn(pCallbackData: *const VkDeviceMemoryReportCallbackDataEXT, pUserData: *mut c_void);
pub type NonNullPFN_vkDeviceWaitIdle = unsafe extern "system" fn(device: VkDevice) -> VkResult;
pub type NonNullPFN_vkDisplayPowerControlEXT = unsafe extern "system" fn(device: VkDevice, display: VkDisplayKHR, pDisplayPowerInfo: *const VkDisplayPowerInfoEXT) -> VkResult;
pub type NonNullPFN_vkEndCommandBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer) -> VkResult;
pub type NonNullPFN_vkEnumerateDeviceExtensionProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pLayerName: *const c_char, pPropertyCount: *mut u32, pProperties: *mut VkExtensionProperties) -> VkResult;
pub type NonNullPFN_vkEnumerateDeviceLayerProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkLayerProperties) -> VkResult;
pub type NonNullPFN_vkEnumerateInstanceExtensionProperties = unsafe extern "system" fn(pLayerName: *const c_char, pPropertyCount: *mut u32, pProperties: *mut VkExtensionProperties) -> VkResult;
pub type NonNullPFN_vkEnumerateInstanceLayerProperties = unsafe extern "system" fn(pPropertyCount: *mut u32, pProperties: *mut VkLayerProperties) -> VkResult;
pub type NonNullPFN_vkEnumerateInstanceVersion = unsafe extern "system" fn(pApiVersion: *mut u32) -> VkResult;
pub type NonNullPFN_vkEnumeratePhysicalDeviceGroups = unsafe extern "system" fn(instance: VkInstance, pPhysicalDeviceGroupCount: *mut u32, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupProperties) -> VkResult;
pub type NonNullPFN_vkEnumeratePhysicalDeviceGroupsKHR = unsafe extern "system" fn(instance: VkInstance, pPhysicalDeviceGroupCount: *mut u32, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupProperties) -> VkResult;
pub type NonNullPFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pCounterCount: *mut u32, pCounters: *mut VkPerformanceCounterARM, pCounterDescriptions: *mut VkPerformanceCounterDescriptionARM) -> VkResult;
pub type NonNullPFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pCounterCount: *mut u32, pCounters: *mut VkPerformanceCounterKHR, pCounterDescriptions: *mut VkPerformanceCounterDescriptionKHR) -> VkResult;
pub type NonNullPFN_vkEnumeratePhysicalDevices = unsafe extern "system" fn(instance: VkInstance, pPhysicalDeviceCount: *mut u32, pPhysicalDevices: *mut VkPhysicalDevice) -> VkResult;
pub type NonNullPFN_vkFlushMappedMemoryRanges = unsafe extern "system" fn(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;
pub type NonNullPFN_vkFreeCommandBuffers = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: u32, pCommandBuffers: *const VkCommandBuffer);
pub type NonNullPFN_vkFreeDescriptorSets = unsafe extern "system" fn(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: u32, pDescriptorSets: *const VkDescriptorSet) -> VkResult;
pub type NonNullPFN_vkFreeFunction = unsafe extern "system" fn(pUserData: *mut c_void, pMemory: *mut c_void);
pub type NonNullPFN_vkFreeMemory = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, pAllocator: *const VkAllocationCallbacks);
pub type NonNullPFN_vkGetAccelerationStructureBuildSizesKHR = unsafe extern "system" fn(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: *const VkAccelerationStructureBuildGeometryInfoKHR, pMaxPrimitiveCounts: *const u32, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);
pub type NonNullPFN_vkGetAccelerationStructureDeviceAddressKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkAccelerationStructureDeviceAddressInfoKHR) -> VkDeviceAddress;
pub type NonNullPFN_vkGetAccelerationStructureHandleNV = unsafe extern "system" fn(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, dataSize: usize, pData: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetAccelerationStructureMemoryRequirementsNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkAccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: *mut VkMemoryRequirements2KHR);
pub type NonNullPFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkAccelerationStructureCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetBufferDeviceAddress = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;
pub type NonNullPFN_vkGetBufferDeviceAddressEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;
pub type NonNullPFN_vkGetBufferDeviceAddressKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;
pub type NonNullPFN_vkGetBufferMemoryRequirements = unsafe extern "system" fn(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: *mut VkMemoryRequirements);
pub type NonNullPFN_vkGetBufferMemoryRequirements2 = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
pub type NonNullPFN_vkGetBufferMemoryRequirements2KHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
pub type NonNullPFN_vkGetBufferOpaqueCaptureAddress = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> u64;
pub type NonNullPFN_vkGetBufferOpaqueCaptureAddressKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> u64;
pub type NonNullPFN_vkGetBufferOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetCalibratedTimestampsEXT = unsafe extern "system" fn(device: VkDevice, timestampCount: u32, pTimestampInfos: *const VkCalibratedTimestampInfoKHR, pTimestamps: *mut u64, pMaxDeviation: *mut u64) -> VkResult;
pub type NonNullPFN_vkGetCalibratedTimestampsKHR = unsafe extern "system" fn(device: VkDevice, timestampCount: u32, pTimestampInfos: *const VkCalibratedTimestampInfoKHR, pTimestamps: *mut u64, pMaxDeviation: *mut u64) -> VkResult;
pub type NonNullPFN_vkGetClusterAccelerationStructureBuildSizesNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkClusterAccelerationStructureInputInfoNV, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);
pub type NonNullPFN_vkGetDataGraphPipelineAvailablePropertiesARM = unsafe extern "system" fn(device: VkDevice, pPipelineInfo: *const VkDataGraphPipelineInfoARM, pPropertiesCount: *mut u32, pProperties: *mut VkDataGraphPipelinePropertyARM) -> VkResult;
pub type NonNullPFN_vkGetDataGraphPipelinePropertiesARM = unsafe extern "system" fn(device: VkDevice, pPipelineInfo: *const VkDataGraphPipelineInfoARM, propertiesCount: u32, pProperties: *mut VkDataGraphPipelinePropertyQueryResultARM) -> VkResult;
pub type NonNullPFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDataGraphPipelineSessionBindPointRequirementsInfoARM, pBindPointRequirementCount: *mut u32, pBindPointRequirements: *mut VkDataGraphPipelineSessionBindPointRequirementARM) -> VkResult;
pub type NonNullPFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDataGraphPipelineSessionMemoryRequirementsInfoARM, pMemoryRequirements: *mut VkMemoryRequirements2);
pub type NonNullPFN_vkGetDeferredOperationMaxConcurrencyKHR = unsafe extern "system" fn(device: VkDevice, operation: VkDeferredOperationKHR) -> u32;
pub type NonNullPFN_vkGetDeferredOperationResultKHR = unsafe extern "system" fn(device: VkDevice, operation: VkDeferredOperationKHR) -> VkResult;
pub type NonNullPFN_vkGetDescriptorEXT = unsafe extern "system" fn(device: VkDevice, pDescriptorInfo: *const VkDescriptorGetInfoEXT, dataSize: usize, pDescriptor: *mut c_void);
pub type NonNullPFN_vkGetDescriptorSetHostMappingVALVE = unsafe extern "system" fn(device: VkDevice, descriptorSet: VkDescriptorSet, ppData: *mut *mut c_void);
pub type NonNullPFN_vkGetDescriptorSetLayoutBindingOffsetEXT = unsafe extern "system" fn(device: VkDevice, layout: VkDescriptorSetLayout, binding: u32, pOffset: *mut VkDeviceSize);
pub type NonNullPFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE = unsafe extern "system" fn(device: VkDevice, pBindingReference: *const VkDescriptorSetBindingReferenceVALVE, pHostMapping: *mut VkDescriptorSetLayoutHostMappingInfoVALVE);
pub type NonNullPFN_vkGetDescriptorSetLayoutSizeEXT = unsafe extern "system" fn(device: VkDevice, layout: VkDescriptorSetLayout, pLayoutSizeInBytes: *mut VkDeviceSize);
pub type NonNullPFN_vkGetDescriptorSetLayoutSupport = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport);
pub type NonNullPFN_vkGetDescriptorSetLayoutSupportKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport);
pub type NonNullPFN_vkGetDeviceAccelerationStructureCompatibilityKHR = unsafe extern "system" fn(device: VkDevice, pVersionInfo: *const VkAccelerationStructureVersionInfoKHR, pCompatibility: *mut VkAccelerationStructureCompatibilityKHR);
pub type NonNullPFN_vkGetDeviceBufferMemoryRequirements = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceBufferMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
pub type NonNullPFN_vkGetDeviceBufferMemoryRequirementsKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceBufferMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
pub type NonNullPFN_vkGetDeviceFaultInfoEXT = unsafe extern "system" fn(device: VkDevice, pFaultCounts: *mut VkDeviceFaultCountsEXT, pFaultInfo: *mut VkDeviceFaultInfoEXT) -> VkResult;
pub type NonNullPFN_vkGetDeviceGroupPeerMemoryFeatures = unsafe extern "system" fn(device: VkDevice, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags);
pub type NonNullPFN_vkGetDeviceGroupPeerMemoryFeaturesKHR = unsafe extern "system" fn(device: VkDevice, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags);
pub type NonNullPFN_vkGetDeviceGroupPresentCapabilitiesKHR = unsafe extern "system" fn(device: VkDevice, pDeviceGroupPresentCapabilities: *mut VkDeviceGroupPresentCapabilitiesKHR) -> VkResult;
pub type NonNullPFN_vkGetDeviceGroupSurfacePresentModesKHR = unsafe extern "system" fn(device: VkDevice, surface: VkSurfaceKHR, pModes: *mut VkDeviceGroupPresentModeFlagsKHR) -> VkResult;
pub type NonNullPFN_vkGetDeviceImageMemoryRequirements = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
pub type NonNullPFN_vkGetDeviceImageMemoryRequirementsKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
pub type NonNullPFN_vkGetDeviceImageSparseMemoryRequirements = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
pub type NonNullPFN_vkGetDeviceImageSparseMemoryRequirementsKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
pub type NonNullPFN_vkGetDeviceImageSubresourceLayout = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageSubresourceInfo, pLayout: *mut VkSubresourceLayout2);
pub type NonNullPFN_vkGetDeviceImageSubresourceLayoutKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageSubresourceInfo, pLayout: *mut VkSubresourceLayout2);
pub type NonNullPFN_vkGetDeviceMemoryCommitment = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: *mut VkDeviceSize);
pub type NonNullPFN_vkGetDeviceMemoryOpaqueCaptureAddress = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo) -> u64;
pub type NonNullPFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo) -> u64;
pub type NonNullPFN_vkGetDeviceMicromapCompatibilityEXT = unsafe extern "system" fn(device: VkDevice, pVersionInfo: *const VkMicromapVersionInfoEXT, pCompatibility: *mut VkAccelerationStructureCompatibilityKHR);
pub type NonNullPFN_vkGetDeviceProcAddr = unsafe extern "system" fn(device: VkDevice, pName: *const c_char) -> PFN_vkVoidFunction;
pub type NonNullPFN_vkGetDeviceQueue = unsafe extern "system" fn(device: VkDevice, queueFamilyIndex: u32, queueIndex: u32, pQueue: *mut VkQueue);
pub type NonNullPFN_vkGetDeviceQueue2 = unsafe extern "system" fn(device: VkDevice, pQueueInfo: *const VkDeviceQueueInfo2, pQueue: *mut VkQueue);
pub type NonNullPFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = unsafe extern "system" fn(device: VkDevice, renderpass: VkRenderPass, pMaxWorkgroupSize: *mut VkExtent2D) -> VkResult;
pub type NonNullPFN_vkGetDeviceTensorMemoryRequirementsARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceTensorMemoryRequirementsARM, pMemoryRequirements: *mut VkMemoryRequirements2);
pub type NonNullPFN_vkGetDisplayModeProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut u32, pProperties: *mut VkDisplayModeProperties2KHR) -> VkResult;
pub type NonNullPFN_vkGetDisplayModePropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut u32, pProperties: *mut VkDisplayModePropertiesKHR) -> VkResult;
pub type NonNullPFN_vkGetDisplayPlaneCapabilities2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pDisplayPlaneInfo: *const VkDisplayPlaneInfo2KHR, pCapabilities: *mut VkDisplayPlaneCapabilities2KHR) -> VkResult;
pub type NonNullPFN_vkGetDisplayPlaneCapabilitiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: u32, pCapabilities: *mut VkDisplayPlaneCapabilitiesKHR) -> VkResult;
pub type NonNullPFN_vkGetDisplayPlaneSupportedDisplaysKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, planeIndex: u32, pDisplayCount: *mut u32, pDisplays: *mut VkDisplayKHR) -> VkResult;
pub type NonNullPFN_vkGetDrmDisplayEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, drmFd: i32, connectorId: u32, display: *mut VkDisplayKHR) -> VkResult;
pub type NonNullPFN_vkGetDynamicRenderingTilePropertiesQCOM = unsafe extern "system" fn(device: VkDevice, pRenderingInfo: *const VkRenderingInfo, pProperties: *mut VkTilePropertiesQCOM) -> VkResult;
pub type NonNullPFN_vkGetEncodedVideoSessionParametersKHR = unsafe extern "system" fn(device: VkDevice, pVideoSessionParametersInfo: *const VkVideoEncodeSessionParametersGetInfoKHR, pFeedbackInfo: *mut VkVideoEncodeSessionParametersFeedbackInfoKHR, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetEventStatus = unsafe extern "system" fn(device: VkDevice, event: VkEvent) -> VkResult;
pub type NonNullPFN_vkGetExternalComputeQueueDataNV = unsafe extern "system" fn(externalQueue: VkExternalComputeQueueNV, params: *mut VkExternalComputeQueueDataParamsNV, pData: *mut c_void);
pub type NonNullPFN_vkGetFenceFdKHR = unsafe extern "system" fn(device: VkDevice, pGetFdInfo: *const VkFenceGetFdInfoKHR, pFd: *mut c_int) -> VkResult;
pub type NonNullPFN_vkGetFenceStatus = unsafe extern "system" fn(device: VkDevice, fence: VkFence) -> VkResult;
pub type NonNullPFN_vkGetFramebufferTilePropertiesQCOM = unsafe extern "system" fn(device: VkDevice, framebuffer: VkFramebuffer, pPropertiesCount: *mut u32, pProperties: *mut VkTilePropertiesQCOM) -> VkResult;
pub type NonNullPFN_vkGetGeneratedCommandsMemoryRequirementsEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoEXT, pMemoryRequirements: *mut VkMemoryRequirements2);
pub type NonNullPFN_vkGetGeneratedCommandsMemoryRequirementsNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: *mut VkMemoryRequirements2);
pub type NonNullPFN_vkGetImageDrmFormatModifierPropertiesEXT = unsafe extern "system" fn(device: VkDevice, image: VkImage, pProperties: *mut VkImageDrmFormatModifierPropertiesEXT) -> VkResult;
pub type NonNullPFN_vkGetImageMemoryRequirements = unsafe extern "system" fn(device: VkDevice, image: VkImage, pMemoryRequirements: *mut VkMemoryRequirements);
pub type NonNullPFN_vkGetImageMemoryRequirements2 = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
pub type NonNullPFN_vkGetImageMemoryRequirements2KHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
pub type NonNullPFN_vkGetImageOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetImageSparseMemoryRequirements = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements);
pub type NonNullPFN_vkGetImageSparseMemoryRequirements2 = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
pub type NonNullPFN_vkGetImageSparseMemoryRequirements2KHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
pub type NonNullPFN_vkGetImageSubresourceLayout = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource, pLayout: *mut VkSubresourceLayout);
pub type NonNullPFN_vkGetImageSubresourceLayout2 = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);
pub type NonNullPFN_vkGetImageSubresourceLayout2EXT = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);
pub type NonNullPFN_vkGetImageSubresourceLayout2KHR = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);
pub type NonNullPFN_vkGetImageViewAddressNVX = unsafe extern "system" fn(device: VkDevice, imageView: VkImageView, pProperties: *mut VkImageViewAddressPropertiesNVX) -> VkResult;
pub type NonNullPFN_vkGetImageViewHandle64NVX = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageViewHandleInfoNVX) -> u64;
pub type NonNullPFN_vkGetImageViewHandleNVX = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageViewHandleInfoNVX) -> u32;
pub type NonNullPFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageViewCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetInstanceProcAddr = unsafe extern "system" fn(instance: VkInstance, pName: *const c_char) -> PFN_vkVoidFunction;
pub type NonNullPFN_vkGetInstanceProcAddrLUNARG = unsafe extern "system" fn(instance: VkInstance, pName: *const c_char) -> PFN_vkVoidFunction;
pub type NonNullPFN_vkGetLatencyTimingsNV = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pLatencyMarkerInfo: *mut VkGetLatencyMarkerInfoNV);
pub type NonNullPFN_vkGetMemoryFdKHR = unsafe extern "system" fn(device: VkDevice, pGetFdInfo: *const VkMemoryGetFdInfoKHR, pFd: *mut c_int) -> VkResult;
pub type NonNullPFN_vkGetMemoryFdPropertiesKHR = unsafe extern "system" fn(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, fd: c_int, pMemoryFdProperties: *mut VkMemoryFdPropertiesKHR) -> VkResult;
pub type NonNullPFN_vkGetMemoryHostPointerPropertiesEXT = unsafe extern "system" fn(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, pHostPointer: *const c_void, pMemoryHostPointerProperties: *mut VkMemoryHostPointerPropertiesEXT) -> VkResult;
pub type NonNullPFN_vkGetMemoryRemoteAddressNV = unsafe extern "system" fn(device: VkDevice, pMemoryGetRemoteAddressInfo: *const VkMemoryGetRemoteAddressInfoNV, pAddress: *mut VkRemoteAddressNV) -> VkResult;
pub type NonNullPFN_vkGetMicromapBuildSizesEXT = unsafe extern "system" fn(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: *const VkMicromapBuildInfoEXT, pSizeInfo: *mut VkMicromapBuildSizesInfoEXT);
pub type NonNullPFN_vkGetPartitionedAccelerationStructuresBuildSizesNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkPartitionedAccelerationStructureInstancesInputNV, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);
pub type NonNullPFN_vkGetPastPresentationTimingEXT = unsafe extern "system" fn(device: VkDevice, pPastPresentationTimingInfo: *const VkPastPresentationTimingInfoEXT, pPastPresentationTimingProperties: *mut VkPastPresentationTimingPropertiesEXT) -> VkResult;
pub type NonNullPFN_vkGetPastPresentationTimingGOOGLE = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pPresentationTimingCount: *mut u32, pPresentationTimings: *mut VkPastPresentationTimingGOOGLE) -> VkResult;
pub type NonNullPFN_vkGetPerformanceParameterINTEL = unsafe extern "system" fn(device: VkDevice, parameter: VkPerformanceParameterTypeINTEL, pValue: *mut VkPerformanceValueINTEL) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pTimeDomainCount: *mut u32, pTimeDomains: *mut VkTimeDomainKHR) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pTimeDomainCount: *mut u32, pTimeDomains: *mut VkTimeDomainKHR) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixFlexibleDimensionsPropertiesNV) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixPropertiesKHR) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixPropertiesNV) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeVectorPropertiesNV) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPlaneProperties2KHR) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPlanePropertiesKHR) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceDisplayProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayProperties2KHR) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceDisplayPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPropertiesKHR) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceExternalBufferProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: *mut VkExternalBufferProperties);
pub type NonNullPFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: *mut VkExternalBufferProperties);
pub type NonNullPFN_vkGetPhysicalDeviceExternalFenceProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: *mut VkExternalFenceProperties);
pub type NonNullPFN_vkGetPhysicalDeviceExternalFencePropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: *mut VkExternalFenceProperties);
pub type NonNullPFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, typ: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, externalHandleType: VkExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: *mut VkExternalImageFormatPropertiesNV) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceExternalSemaphoreProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties);
pub type NonNullPFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties);
pub type NonNullPFN_vkGetPhysicalDeviceExternalTensorPropertiesARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalTensorInfo: *const VkPhysicalDeviceExternalTensorInfoARM, pExternalTensorProperties: *mut VkExternalTensorPropertiesARM);
pub type NonNullPFN_vkGetPhysicalDeviceFeatures = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures);
pub type NonNullPFN_vkGetPhysicalDeviceFeatures2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2);
pub type NonNullPFN_vkGetPhysicalDeviceFeatures2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2);
pub type NonNullPFN_vkGetPhysicalDeviceFormatProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties);
pub type NonNullPFN_vkGetPhysicalDeviceFormatProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2);
pub type NonNullPFN_vkGetPhysicalDeviceFormatProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2);
pub type NonNullPFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFragmentShadingRateCount: *mut u32, pFragmentShadingRates: *mut VkPhysicalDeviceFragmentShadingRateKHR) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceImageFormatProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, typ: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: *mut VkImageFormatProperties) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceImageFormatProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: *mut VkImageFormatProperties2) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceImageFormatProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: *mut VkImageFormatProperties2) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceMemoryProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties);
pub type NonNullPFN_vkGetPhysicalDeviceMemoryProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2);
pub type NonNullPFN_vkGetPhysicalDeviceMemoryProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2);
pub type NonNullPFN_vkGetPhysicalDeviceMultisamplePropertiesEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, samples: VkSampleCountFlagBits, pMultisampleProperties: *mut VkMultisamplePropertiesEXT);
pub type NonNullPFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pOpticalFlowImageFormatInfo: *const VkOpticalFlowImageFormatInfoNV, pFormatCount: *mut u32, pImageFormatProperties: *mut VkOpticalFlowImageFormatPropertiesNV) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDevicePresentRectanglesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: *mut u32, pRects: *mut VkRect2D) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties);
pub type NonNullPFN_vkGetPhysicalDeviceProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2);
pub type NonNullPFN_vkGetPhysicalDeviceProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2);
pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyDataGraphProcessingEngineInfo: *const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM, pQueueFamilyDataGraphProcessingEngineProperties: *mut VkQueueFamilyDataGraphProcessingEnginePropertiesARM);
pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pQueueFamilyDataGraphPropertyCount: *mut u32, pQueueFamilyDataGraphProperties: *mut VkQueueFamilyDataGraphPropertiesARM) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPerformanceQueryCreateInfo: *const VkQueryPoolPerformanceCreateInfoKHR, pNumPasses: *mut u32);
pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties);
pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties2);
pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties2);
pub type NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, typ: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties);
pub type NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties2);
pub type NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties2);
pub type NonNullPFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pCombinationCount: *mut u32, pCombinations: *mut VkFramebufferMixedSamplesCombinationNV) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2EXT) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2KHR) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilitiesKHR) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceSurfaceFormats2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceFormatCount: *mut u32, pSurfaceFormats: *mut VkSurfaceFormat2KHR) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceSurfaceFormatsKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: *mut u32, pSurfaceFormats: *mut VkSurfaceFormatKHR) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceSurfacePresentModesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: *mut u32, pPresentModes: *mut VkPresentModeKHR) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceSurfaceSupportKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, surface: VkSurfaceKHR, pSupported: *mut VkBool32) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceToolProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pToolCount: *mut u32, pToolProperties: *mut VkPhysicalDeviceToolProperties) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceToolPropertiesEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pToolCount: *mut u32, pToolProperties: *mut VkPhysicalDeviceToolProperties) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pVideoProfile: *const VkVideoProfileInfoKHR, pCapabilities: *mut VkVideoCapabilitiesKHR) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQualityLevelInfo: *const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR, pQualityLevelProperties: *mut VkVideoEncodeQualityLevelPropertiesKHR) -> VkResult;
pub type NonNullPFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pVideoFormatInfo: *const VkPhysicalDeviceVideoFormatInfoKHR, pVideoFormatPropertyCount: *mut u32, pVideoFormatProperties: *mut VkVideoFormatPropertiesKHR) -> VkResult;
pub type NonNullPFN_vkGetPipelineBinaryDataKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkPipelineBinaryDataInfoKHR, pPipelineBinaryKey: *mut VkPipelineBinaryKeyKHR, pPipelineBinaryDataSize: *mut usize, pPipelineBinaryData: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetPipelineCacheData = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetPipelineExecutableInternalRepresentationsKHR = unsafe extern "system" fn(device: VkDevice, pExecutableInfo: *const VkPipelineExecutableInfoKHR, pInternalRepresentationCount: *mut u32, pInternalRepresentations: *mut VkPipelineExecutableInternalRepresentationKHR) -> VkResult;
pub type NonNullPFN_vkGetPipelineExecutablePropertiesKHR = unsafe extern "system" fn(device: VkDevice, pPipelineInfo: *const VkPipelineInfoKHR, pExecutableCount: *mut u32, pProperties: *mut VkPipelineExecutablePropertiesKHR) -> VkResult;
pub type NonNullPFN_vkGetPipelineExecutableStatisticsKHR = unsafe extern "system" fn(device: VkDevice, pExecutableInfo: *const VkPipelineExecutableInfoKHR, pStatisticCount: *mut u32, pStatistics: *mut VkPipelineExecutableStatisticKHR) -> VkResult;
pub type NonNullPFN_vkGetPipelineIndirectDeviceAddressNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkPipelineIndirectDeviceAddressInfoNV) -> VkDeviceAddress;
pub type NonNullPFN_vkGetPipelineIndirectMemoryRequirementsNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkComputePipelineCreateInfo, pMemoryRequirements: *mut VkMemoryRequirements2);
pub type NonNullPFN_vkGetPipelineKeyKHR = unsafe extern "system" fn(device: VkDevice, pPipelineCreateInfo: *const VkPipelineCreateInfoKHR, pPipelineKey: *mut VkPipelineBinaryKeyKHR) -> VkResult;
pub type NonNullPFN_vkGetPipelinePropertiesEXT = unsafe extern "system" fn(device: VkDevice, pPipelineInfo: *const VkPipelineInfoEXT, pPipelineProperties: *mut VkBaseOutStructure) -> VkResult;
pub type NonNullPFN_vkGetPrivateData = unsafe extern "system" fn(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, pData: *mut u64);
pub type NonNullPFN_vkGetPrivateDataEXT = unsafe extern "system" fn(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, pData: *mut u64);
pub type NonNullPFN_vkGetQueryPoolResults = unsafe extern "system" fn(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dataSize: usize, pData: *mut c_void, stride: VkDeviceSize, flags: VkQueryResultFlags) -> VkResult;
pub type NonNullPFN_vkGetQueueCheckpointData2NV = unsafe extern "system" fn(queue: VkQueue, pCheckpointDataCount: *mut u32, pCheckpointData: *mut VkCheckpointData2NV);
pub type NonNullPFN_vkGetQueueCheckpointDataNV = unsafe extern "system" fn(queue: VkQueue, pCheckpointDataCount: *mut u32, pCheckpointData: *mut VkCheckpointDataNV);
pub type NonNullPFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetRayTracingShaderGroupHandlesKHR = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetRayTracingShaderGroupHandlesNV = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetRayTracingShaderGroupStackSizeKHR = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, group: u32, groupShader: VkShaderGroupShaderKHR) -> VkDeviceSize;
pub type NonNullPFN_vkGetRefreshCycleDurationGOOGLE = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pDisplayTimingProperties: *mut VkRefreshCycleDurationGOOGLE) -> VkResult;
pub type NonNullPFN_vkGetRenderAreaGranularity = unsafe extern "system" fn(device: VkDevice, renderPass: VkRenderPass, pGranularity: *mut VkExtent2D);
pub type NonNullPFN_vkGetRenderingAreaGranularity = unsafe extern "system" fn(device: VkDevice, pRenderingAreaInfo: *const VkRenderingAreaInfo, pGranularity: *mut VkExtent2D);
pub type NonNullPFN_vkGetRenderingAreaGranularityKHR = unsafe extern "system" fn(device: VkDevice, pRenderingAreaInfo: *const VkRenderingAreaInfo, pGranularity: *mut VkExtent2D);
pub type NonNullPFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkSamplerCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetSemaphoreCounterValue = unsafe extern "system" fn(device: VkDevice, semaphore: VkSemaphore, pValue: *mut u64) -> VkResult;
pub type NonNullPFN_vkGetSemaphoreCounterValueKHR = unsafe extern "system" fn(device: VkDevice, semaphore: VkSemaphore, pValue: *mut u64) -> VkResult;
pub type NonNullPFN_vkGetSemaphoreFdKHR = unsafe extern "system" fn(device: VkDevice, pGetFdInfo: *const VkSemaphoreGetFdInfoKHR, pFd: *mut c_int) -> VkResult;
pub type NonNullPFN_vkGetShaderBinaryDataEXT = unsafe extern "system" fn(device: VkDevice, shader: VkShaderEXT, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetShaderInfoAMD = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, shaderStage: VkShaderStageFlagBits, infoType: VkShaderInfoTypeAMD, pInfoSize: *mut usize, pInfo: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetShaderModuleCreateInfoIdentifierEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pIdentifier: *mut VkShaderModuleIdentifierEXT);
pub type NonNullPFN_vkGetShaderModuleIdentifierEXT = unsafe extern "system" fn(device: VkDevice, shaderModule: VkShaderModule, pIdentifier: *mut VkShaderModuleIdentifierEXT);
pub type NonNullPFN_vkGetSwapchainCounterEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, counter: VkSurfaceCounterFlagBitsEXT, pCounterValue: *mut u64) -> VkResult;
pub type NonNullPFN_vkGetSwapchainImagesKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: *mut u32, pSwapchainImages: *mut VkImage) -> VkResult;
pub type NonNullPFN_vkGetSwapchainStatusKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR) -> VkResult;
pub type NonNullPFN_vkGetSwapchainTimeDomainPropertiesEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainTimeDomainProperties: *mut VkSwapchainTimeDomainPropertiesEXT, pTimeDomainsCounter: *mut u64) -> VkResult;
pub type NonNullPFN_vkGetSwapchainTimingPropertiesEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainTimingProperties: *mut VkSwapchainTimingPropertiesEXT, pSwapchainTimingPropertiesCounter: *mut u64) -> VkResult;
pub type NonNullPFN_vkGetTensorMemoryRequirementsARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkTensorMemoryRequirementsInfoARM, pMemoryRequirements: *mut VkMemoryRequirements2);
pub type NonNullPFN_vkGetTensorOpaqueCaptureDescriptorDataARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkTensorCaptureDescriptorDataInfoARM, pData: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkTensorViewCaptureDescriptorDataInfoARM, pData: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetValidationCacheDataEXT = unsafe extern "system" fn(device: VkDevice, validationCache: VkValidationCacheEXT, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
pub type NonNullPFN_vkGetVideoSessionMemoryRequirementsKHR = unsafe extern "system" fn(device: VkDevice, videoSession: VkVideoSessionKHR, pMemoryRequirementsCount: *mut u32, pMemoryRequirements: *mut VkVideoSessionMemoryRequirementsKHR) -> VkResult;
pub type NonNullPFN_vkImportFenceFdKHR = unsafe extern "system" fn(device: VkDevice, pImportFenceFdInfo: *const VkImportFenceFdInfoKHR) -> VkResult;
pub type NonNullPFN_vkImportSemaphoreFdKHR = unsafe extern "system" fn(device: VkDevice, pImportSemaphoreFdInfo: *const VkImportSemaphoreFdInfoKHR) -> VkResult;
pub type NonNullPFN_vkInitializePerformanceApiINTEL = unsafe extern "system" fn(device: VkDevice, pInitializeInfo: *const VkInitializePerformanceApiInfoINTEL) -> VkResult;
pub type NonNullPFN_vkInternalAllocationNotification = unsafe extern "system" fn(pUserData: *mut c_void, size: usize, allocationType: VkInternalAllocationType, allocationScope: VkSystemAllocationScope);
pub type NonNullPFN_vkInternalFreeNotification = unsafe extern "system" fn(pUserData: *mut c_void, size: usize, allocationType: VkInternalAllocationType, allocationScope: VkSystemAllocationScope);
pub type NonNullPFN_vkInvalidateMappedMemoryRanges = unsafe extern "system" fn(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;
pub type NonNullPFN_vkLatencySleepNV = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSleepInfo: *const VkLatencySleepInfoNV) -> VkResult;
pub type NonNullPFN_vkMapMemory = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: *mut *mut c_void) -> VkResult;
pub type NonNullPFN_vkMapMemory2 = unsafe extern "system" fn(device: VkDevice, pMemoryMapInfo: *const VkMemoryMapInfo, ppData: *mut *mut c_void) -> VkResult;
pub type NonNullPFN_vkMapMemory2KHR = unsafe extern "system" fn(device: VkDevice, pMemoryMapInfo: *const VkMemoryMapInfo, ppData: *mut *mut c_void) -> VkResult;
pub type NonNullPFN_vkMergePipelineCaches = unsafe extern "system" fn(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: u32, pSrcCaches: *const VkPipelineCache) -> VkResult;
pub type NonNullPFN_vkMergeValidationCachesEXT = unsafe extern "system" fn(device: VkDevice, dstCache: VkValidationCacheEXT, srcCacheCount: u32, pSrcCaches: *const VkValidationCacheEXT) -> VkResult;
pub type NonNullPFN_vkQueueBeginDebugUtilsLabelEXT = unsafe extern "system" fn(queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT);
pub type NonNullPFN_vkQueueBindSparse = unsafe extern "system" fn(queue: VkQueue, bindInfoCount: u32, pBindInfo: *const VkBindSparseInfo, fence: VkFence) -> VkResult;
pub type NonNullPFN_vkQueueEndDebugUtilsLabelEXT = unsafe extern "system" fn(queue: VkQueue);
pub type NonNullPFN_vkQueueInsertDebugUtilsLabelEXT = unsafe extern "system" fn(queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT);
pub type NonNullPFN_vkQueueNotifyOutOfBandNV = unsafe extern "system" fn(queue: VkQueue, pQueueTypeInfo: *const VkOutOfBandQueueTypeInfoNV);
pub type NonNullPFN_vkQueuePresentKHR = unsafe extern "system" fn(queue: VkQueue, pPresentInfo: *const VkPresentInfoKHR) -> VkResult;
pub type NonNullPFN_vkQueueSetPerformanceConfigurationINTEL = unsafe extern "system" fn(queue: VkQueue, configuration: VkPerformanceConfigurationINTEL) -> VkResult;
pub type NonNullPFN_vkQueueSubmit = unsafe extern "system" fn(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo, fence: VkFence) -> VkResult;
pub type NonNullPFN_vkQueueSubmit2 = unsafe extern "system" fn(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo2, fence: VkFence) -> VkResult;
pub type NonNullPFN_vkQueueSubmit2KHR = unsafe extern "system" fn(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo2, fence: VkFence) -> VkResult;
pub type NonNullPFN_vkQueueWaitIdle = unsafe extern "system" fn(queue: VkQueue) -> VkResult;
pub type NonNullPFN_vkReallocationFunction = unsafe extern "system" fn(pUserData: *mut c_void, pOriginal: *mut c_void, size: usize, alignment: usize, allocationScope: VkSystemAllocationScope) -> *mut c_void;
pub type NonNullPFN_vkRegisterDeviceEventEXT = unsafe extern "system" fn(device: VkDevice, pDeviceEventInfo: *const VkDeviceEventInfoEXT, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;
pub type NonNullPFN_vkRegisterDisplayEventEXT = unsafe extern "system" fn(device: VkDevice, display: VkDisplayKHR, pDisplayEventInfo: *const VkDisplayEventInfoEXT, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;
pub type NonNullPFN_vkReleaseCapturedPipelineDataKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkReleaseCapturedPipelineDataInfoKHR, pAllocator: *const VkAllocationCallbacks) -> VkResult;
pub type NonNullPFN_vkReleaseDisplayEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR) -> VkResult;
pub type NonNullPFN_vkReleasePerformanceConfigurationINTEL = unsafe extern "system" fn(device: VkDevice, configuration: VkPerformanceConfigurationINTEL) -> VkResult;
pub type NonNullPFN_vkReleaseProfilingLockKHR = unsafe extern "system" fn(device: VkDevice);
pub type NonNullPFN_vkReleaseSwapchainImagesEXT = unsafe extern "system" fn(device: VkDevice, pReleaseInfo: *const VkReleaseSwapchainImagesInfoKHR) -> VkResult;
pub type NonNullPFN_vkReleaseSwapchainImagesKHR = unsafe extern "system" fn(device: VkDevice, pReleaseInfo: *const VkReleaseSwapchainImagesInfoKHR) -> VkResult;
pub type NonNullPFN_vkResetCommandBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags) -> VkResult;
pub type NonNullPFN_vkResetCommandPool = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags) -> VkResult;
pub type NonNullPFN_vkResetDescriptorPool = unsafe extern "system" fn(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags) -> VkResult;
pub type NonNullPFN_vkResetEvent = unsafe extern "system" fn(device: VkDevice, event: VkEvent) -> VkResult;
pub type NonNullPFN_vkResetFences = unsafe extern "system" fn(device: VkDevice, fenceCount: u32, pFences: *const VkFence) -> VkResult;
pub type NonNullPFN_vkResetQueryPool = unsafe extern "system" fn(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);
pub type NonNullPFN_vkResetQueryPoolEXT = unsafe extern "system" fn(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);
pub type NonNullPFN_vkSetDebugUtilsObjectNameEXT = unsafe extern "system" fn(device: VkDevice, pNameInfo: *const VkDebugUtilsObjectNameInfoEXT) -> VkResult;
pub type NonNullPFN_vkSetDebugUtilsObjectTagEXT = unsafe extern "system" fn(device: VkDevice, pTagInfo: *const VkDebugUtilsObjectTagInfoEXT) -> VkResult;
pub type NonNullPFN_vkSetDeviceMemoryPriorityEXT = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, priority: f32);
pub type NonNullPFN_vkSetEvent = unsafe extern "system" fn(device: VkDevice, event: VkEvent) -> VkResult;
pub type NonNullPFN_vkSetHdrMetadataEXT = unsafe extern "system" fn(device: VkDevice, swapchainCount: u32, pSwapchains: *const VkSwapchainKHR, pMetadata: *const VkHdrMetadataEXT);
pub type NonNullPFN_vkSetLatencyMarkerNV = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pLatencyMarkerInfo: *const VkSetLatencyMarkerInfoNV);
pub type NonNullPFN_vkSetLatencySleepModeNV = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSleepModeInfo: *const VkLatencySleepModeInfoNV) -> VkResult;
pub type NonNullPFN_vkSetLocalDimmingAMD = unsafe extern "system" fn(device: VkDevice, swapChain: VkSwapchainKHR, localDimmingEnable: VkBool32);
pub type NonNullPFN_vkSetPrivateData = unsafe extern "system" fn(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, data: u64) -> VkResult;
pub type NonNullPFN_vkSetPrivateDataEXT = unsafe extern "system" fn(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, data: u64) -> VkResult;
pub type NonNullPFN_vkSetSwapchainPresentTimingQueueSizeEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, size: u32) -> VkResult;
pub type NonNullPFN_vkSignalSemaphore = unsafe extern "system" fn(device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfo) -> VkResult;
pub type NonNullPFN_vkSignalSemaphoreKHR = unsafe extern "system" fn(device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfo) -> VkResult;
pub type NonNullPFN_vkSubmitDebugUtilsMessageEXT = unsafe extern "system" fn(instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: *const VkDebugUtilsMessengerCallbackDataEXT);
pub type NonNullPFN_vkTransitionImageLayout = unsafe extern "system" fn(device: VkDevice, transitionCount: u32, pTransitions: *const VkHostImageLayoutTransitionInfo) -> VkResult;
pub type NonNullPFN_vkTransitionImageLayoutEXT = unsafe extern "system" fn(device: VkDevice, transitionCount: u32, pTransitions: *const VkHostImageLayoutTransitionInfo) -> VkResult;
pub type NonNullPFN_vkTrimCommandPool = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags);
pub type NonNullPFN_vkTrimCommandPoolKHR = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags);
pub type NonNullPFN_vkUninitializePerformanceApiINTEL = unsafe extern "system" fn(device: VkDevice);
pub type NonNullPFN_vkUnmapMemory = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory);
pub type NonNullPFN_vkUnmapMemory2 = unsafe extern "system" fn(device: VkDevice, pMemoryUnmapInfo: *const VkMemoryUnmapInfo) -> VkResult;
pub type NonNullPFN_vkUnmapMemory2KHR = unsafe extern "system" fn(device: VkDevice, pMemoryUnmapInfo: *const VkMemoryUnmapInfo) -> VkResult;
pub type NonNullPFN_vkUpdateDescriptorSetWithTemplate = unsafe extern "system" fn(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: *const c_void);
pub type NonNullPFN_vkUpdateDescriptorSetWithTemplateKHR = unsafe extern "system" fn(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: *const c_void);
pub type NonNullPFN_vkUpdateDescriptorSets = unsafe extern "system" fn(device: VkDevice, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet, descriptorCopyCount: u32, pDescriptorCopies: *const VkCopyDescriptorSet);
pub type NonNullPFN_vkUpdateIndirectExecutionSetPipelineEXT = unsafe extern "system" fn(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, executionSetWriteCount: u32, pExecutionSetWrites: *const VkWriteIndirectExecutionSetPipelineEXT);
pub type NonNullPFN_vkUpdateIndirectExecutionSetShaderEXT = unsafe extern "system" fn(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, executionSetWriteCount: u32, pExecutionSetWrites: *const VkWriteIndirectExecutionSetShaderEXT);
pub type NonNullPFN_vkUpdateVideoSessionParametersKHR = unsafe extern "system" fn(device: VkDevice, videoSessionParameters: VkVideoSessionParametersKHR, pUpdateInfo: *const VkVideoSessionParametersUpdateInfoKHR) -> VkResult;
pub type NonNullPFN_vkVoidFunction = unsafe extern "system" fn();
pub type NonNullPFN_vkWaitForFences = unsafe extern "system" fn(device: VkDevice, fenceCount: u32, pFences: *const VkFence, waitAll: VkBool32, timeout: u64) -> VkResult;
pub type NonNullPFN_vkWaitForPresent2KHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pPresentWait2Info: *const VkPresentWait2InfoKHR) -> VkResult;
pub type NonNullPFN_vkWaitForPresentKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, presentId: u64, timeout: u64) -> VkResult;
pub type NonNullPFN_vkWaitSemaphores = unsafe extern "system" fn(device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfo, timeout: u64) -> VkResult;
pub type NonNullPFN_vkWaitSemaphoresKHR = unsafe extern "system" fn(device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfo, timeout: u64) -> VkResult;
pub type NonNullPFN_vkWriteAccelerationStructuresPropertiesKHR = unsafe extern "system" fn(device: VkDevice, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureKHR, queryType: VkQueryType, dataSize: usize, pData: *mut c_void, stride: usize) -> VkResult;
pub type NonNullPFN_vkWriteMicromapsPropertiesEXT = unsafe extern "system" fn(device: VkDevice, micromapCount: u32, pMicromaps: *const VkMicromapEXT, queryType: VkQueryType, dataSize: usize, pData: *mut c_void, stride: usize) -> VkResult;
pub type NonNullVkAccelerationStructureKHR = NonNull<VkAccelerationStructureKHR_T>;
pub type NonNullVkAccelerationStructureNV = NonNull<VkAccelerationStructureNV_T>;
pub type NonNullVkBuffer = NonNull<VkBuffer_T>;
pub type NonNullVkBufferView = NonNull<VkBufferView_T>;
pub type NonNullVkCommandBuffer = NonNull<VkCommandBuffer_T>;
pub type NonNullVkCommandPool = NonNull<VkCommandPool_T>;
pub type NonNullVkCuFunctionNVX = NonNull<VkCuFunctionNVX_T>;
pub type NonNullVkCuModuleNVX = NonNull<VkCuModuleNVX_T>;
pub type NonNullVkDataGraphPipelineSessionARM = NonNull<VkDataGraphPipelineSessionARM_T>;
pub type NonNullVkDebugReportCallbackEXT = NonNull<VkDebugReportCallbackEXT_T>;
pub type NonNullVkDebugUtilsMessengerEXT = NonNull<VkDebugUtilsMessengerEXT_T>;
pub type NonNullVkDeferredOperationKHR = NonNull<VkDeferredOperationKHR_T>;
pub type NonNullVkDescriptorPool = NonNull<VkDescriptorPool_T>;
pub type NonNullVkDescriptorSet = NonNull<VkDescriptorSet_T>;
pub type NonNullVkDescriptorSetLayout = NonNull<VkDescriptorSetLayout_T>;
pub type NonNullVkDescriptorUpdateTemplate = NonNull<VkDescriptorUpdateTemplate_T>;
pub type NonNullVkDescriptorUpdateTemplateKHR = NonNull<VkDescriptorUpdateTemplateKHR_T>;
pub type NonNullVkDevice = NonNull<VkDevice_T>;
pub type NonNullVkDeviceMemory = NonNull<VkDeviceMemory_T>;
pub type NonNullVkDisplayKHR = NonNull<VkDisplayKHR_T>;
pub type NonNullVkDisplayModeKHR = NonNull<VkDisplayModeKHR_T>;
pub type NonNullVkEvent = NonNull<VkEvent_T>;
pub type NonNullVkExternalComputeQueueNV = NonNull<VkExternalComputeQueueNV_T>;
pub type NonNullVkFence = NonNull<VkFence_T>;
pub type NonNullVkFramebuffer = NonNull<VkFramebuffer_T>;
pub type NonNullVkImage = NonNull<VkImage_T>;
pub type NonNullVkImageView = NonNull<VkImageView_T>;
pub type NonNullVkIndirectCommandsLayoutEXT = NonNull<VkIndirectCommandsLayoutEXT_T>;
pub type NonNullVkIndirectCommandsLayoutNV = NonNull<VkIndirectCommandsLayoutNV_T>;
pub type NonNullVkIndirectExecutionSetEXT = NonNull<VkIndirectExecutionSetEXT_T>;
pub type NonNullVkInstance = NonNull<VkInstance_T>;
pub type NonNullVkMicromapEXT = NonNull<VkMicromapEXT_T>;
pub type NonNullVkOpticalFlowSessionNV = NonNull<VkOpticalFlowSessionNV_T>;
pub type NonNullVkPerformanceConfigurationINTEL = NonNull<VkPerformanceConfigurationINTEL_T>;
pub type NonNullVkPhysicalDevice = NonNull<VkPhysicalDevice_T>;
pub type NonNullVkPipeline = NonNull<VkPipeline_T>;
pub type NonNullVkPipelineBinaryKHR = NonNull<VkPipelineBinaryKHR_T>;
pub type NonNullVkPipelineCache = NonNull<VkPipelineCache_T>;
pub type NonNullVkPipelineLayout = NonNull<VkPipelineLayout_T>;
pub type NonNullVkPrivateDataSlot = NonNull<VkPrivateDataSlot_T>;
pub type NonNullVkPrivateDataSlotEXT = NonNull<VkPrivateDataSlotEXT_T>;
pub type NonNullVkQueryPool = NonNull<VkQueryPool_T>;
pub type NonNullVkQueue = NonNull<VkQueue_T>;
pub type NonNullVkRenderPass = NonNull<VkRenderPass_T>;
pub type NonNullVkSampler = NonNull<VkSampler_T>;
pub type NonNullVkSamplerYcbcrConversion = NonNull<VkSamplerYcbcrConversion_T>;
pub type NonNullVkSamplerYcbcrConversionKHR = NonNull<VkSamplerYcbcrConversionKHR_T>;
pub type NonNullVkSemaphore = NonNull<VkSemaphore_T>;
pub type NonNullVkShaderEXT = NonNull<VkShaderEXT_T>;
pub type NonNullVkShaderModule = NonNull<VkShaderModule_T>;
pub type NonNullVkSurfaceKHR = NonNull<VkSurfaceKHR_T>;
pub type NonNullVkSwapchainKHR = NonNull<VkSwapchainKHR_T>;
pub type NonNullVkTensorARM = NonNull<VkTensorARM_T>;
pub type NonNullVkTensorViewARM = NonNull<VkTensorViewARM_T>;
pub type NonNullVkValidationCacheEXT = NonNull<VkValidationCacheEXT_T>;
pub type NonNullVkVideoSessionKHR = NonNull<VkVideoSessionKHR_T>;
pub type NonNullVkVideoSessionParametersKHR = NonNull<VkVideoSessionParametersKHR_T>;
pub type PFN_vkAcquireDrmDisplayEXT = Option<NonNullPFN_vkAcquireDrmDisplayEXT>;
pub type PFN_vkAcquireNextImage2KHR = Option<NonNullPFN_vkAcquireNextImage2KHR>;
pub type PFN_vkAcquireNextImageKHR = Option<NonNullPFN_vkAcquireNextImageKHR>;
pub type PFN_vkAcquirePerformanceConfigurationINTEL = Option<NonNullPFN_vkAcquirePerformanceConfigurationINTEL>;
pub type PFN_vkAcquireProfilingLockKHR = Option<NonNullPFN_vkAcquireProfilingLockKHR>;
pub type PFN_vkAllocateCommandBuffers = Option<NonNullPFN_vkAllocateCommandBuffers>;
pub type PFN_vkAllocateDescriptorSets = Option<NonNullPFN_vkAllocateDescriptorSets>;
pub type PFN_vkAllocateMemory = Option<NonNullPFN_vkAllocateMemory>;
pub type PFN_vkAllocationFunction = Option<NonNullPFN_vkAllocationFunction>;
pub type PFN_vkAntiLagUpdateAMD = Option<NonNullPFN_vkAntiLagUpdateAMD>;
pub type PFN_vkBeginCommandBuffer = Option<NonNullPFN_vkBeginCommandBuffer>;
pub type PFN_vkBindAccelerationStructureMemoryNV = Option<NonNullPFN_vkBindAccelerationStructureMemoryNV>;
pub type PFN_vkBindBufferMemory = Option<NonNullPFN_vkBindBufferMemory>;
pub type PFN_vkBindBufferMemory2 = Option<NonNullPFN_vkBindBufferMemory2>;
pub type PFN_vkBindBufferMemory2KHR = Option<NonNullPFN_vkBindBufferMemory2KHR>;
pub type PFN_vkBindDataGraphPipelineSessionMemoryARM = Option<NonNullPFN_vkBindDataGraphPipelineSessionMemoryARM>;
pub type PFN_vkBindImageMemory = Option<NonNullPFN_vkBindImageMemory>;
pub type PFN_vkBindImageMemory2 = Option<NonNullPFN_vkBindImageMemory2>;
pub type PFN_vkBindImageMemory2KHR = Option<NonNullPFN_vkBindImageMemory2KHR>;
pub type PFN_vkBindOpticalFlowSessionImageNV = Option<NonNullPFN_vkBindOpticalFlowSessionImageNV>;
pub type PFN_vkBindTensorMemoryARM = Option<NonNullPFN_vkBindTensorMemoryARM>;
pub type PFN_vkBindVideoSessionMemoryKHR = Option<NonNullPFN_vkBindVideoSessionMemoryKHR>;
pub type PFN_vkBuildAccelerationStructuresKHR = Option<NonNullPFN_vkBuildAccelerationStructuresKHR>;
pub type PFN_vkBuildMicromapsEXT = Option<NonNullPFN_vkBuildMicromapsEXT>;
pub type PFN_vkCmdBeginConditionalRenderingEXT = Option<NonNullPFN_vkCmdBeginConditionalRenderingEXT>;
pub type PFN_vkCmdBeginCustomResolveEXT = Option<NonNullPFN_vkCmdBeginCustomResolveEXT>;
pub type PFN_vkCmdBeginDebugUtilsLabelEXT = Option<NonNullPFN_vkCmdBeginDebugUtilsLabelEXT>;
pub type PFN_vkCmdBeginPerTileExecutionQCOM = Option<NonNullPFN_vkCmdBeginPerTileExecutionQCOM>;
pub type PFN_vkCmdBeginQuery = Option<NonNullPFN_vkCmdBeginQuery>;
pub type PFN_vkCmdBeginQueryIndexedEXT = Option<NonNullPFN_vkCmdBeginQueryIndexedEXT>;
pub type PFN_vkCmdBeginRenderPass = Option<NonNullPFN_vkCmdBeginRenderPass>;
pub type PFN_vkCmdBeginRenderPass2 = Option<NonNullPFN_vkCmdBeginRenderPass2>;
pub type PFN_vkCmdBeginRenderPass2KHR = Option<NonNullPFN_vkCmdBeginRenderPass2KHR>;
pub type PFN_vkCmdBeginRendering = Option<NonNullPFN_vkCmdBeginRendering>;
pub type PFN_vkCmdBeginRenderingKHR = Option<NonNullPFN_vkCmdBeginRenderingKHR>;
pub type PFN_vkCmdBeginTransformFeedbackEXT = Option<NonNullPFN_vkCmdBeginTransformFeedbackEXT>;
pub type PFN_vkCmdBeginVideoCodingKHR = Option<NonNullPFN_vkCmdBeginVideoCodingKHR>;
pub type PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = Option<NonNullPFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT>;
pub type PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = Option<NonNullPFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT>;
pub type PFN_vkCmdBindDescriptorBuffersEXT = Option<NonNullPFN_vkCmdBindDescriptorBuffersEXT>;
pub type PFN_vkCmdBindDescriptorSets = Option<NonNullPFN_vkCmdBindDescriptorSets>;
pub type PFN_vkCmdBindDescriptorSets2 = Option<NonNullPFN_vkCmdBindDescriptorSets2>;
pub type PFN_vkCmdBindDescriptorSets2KHR = Option<NonNullPFN_vkCmdBindDescriptorSets2KHR>;
pub type PFN_vkCmdBindIndexBuffer = Option<NonNullPFN_vkCmdBindIndexBuffer>;
pub type PFN_vkCmdBindIndexBuffer2 = Option<NonNullPFN_vkCmdBindIndexBuffer2>;
pub type PFN_vkCmdBindIndexBuffer2KHR = Option<NonNullPFN_vkCmdBindIndexBuffer2KHR>;
pub type PFN_vkCmdBindInvocationMaskHUAWEI = Option<NonNullPFN_vkCmdBindInvocationMaskHUAWEI>;
pub type PFN_vkCmdBindPipeline = Option<NonNullPFN_vkCmdBindPipeline>;
pub type PFN_vkCmdBindPipelineShaderGroupNV = Option<NonNullPFN_vkCmdBindPipelineShaderGroupNV>;
pub type PFN_vkCmdBindShadersEXT = Option<NonNullPFN_vkCmdBindShadersEXT>;
pub type PFN_vkCmdBindShadingRateImageNV = Option<NonNullPFN_vkCmdBindShadingRateImageNV>;
pub type PFN_vkCmdBindTileMemoryQCOM = Option<NonNullPFN_vkCmdBindTileMemoryQCOM>;
pub type PFN_vkCmdBindTransformFeedbackBuffersEXT = Option<NonNullPFN_vkCmdBindTransformFeedbackBuffersEXT>;
pub type PFN_vkCmdBindVertexBuffers = Option<NonNullPFN_vkCmdBindVertexBuffers>;
pub type PFN_vkCmdBindVertexBuffers2 = Option<NonNullPFN_vkCmdBindVertexBuffers2>;
pub type PFN_vkCmdBindVertexBuffers2EXT = Option<NonNullPFN_vkCmdBindVertexBuffers2EXT>;
pub type PFN_vkCmdBlitImage = Option<NonNullPFN_vkCmdBlitImage>;
pub type PFN_vkCmdBlitImage2 = Option<NonNullPFN_vkCmdBlitImage2>;
pub type PFN_vkCmdBlitImage2KHR = Option<NonNullPFN_vkCmdBlitImage2KHR>;
pub type PFN_vkCmdBuildAccelerationStructureNV = Option<NonNullPFN_vkCmdBuildAccelerationStructureNV>;
pub type PFN_vkCmdBuildAccelerationStructuresIndirectKHR = Option<NonNullPFN_vkCmdBuildAccelerationStructuresIndirectKHR>;
pub type PFN_vkCmdBuildAccelerationStructuresKHR = Option<NonNullPFN_vkCmdBuildAccelerationStructuresKHR>;
pub type PFN_vkCmdBuildClusterAccelerationStructureIndirectNV = Option<NonNullPFN_vkCmdBuildClusterAccelerationStructureIndirectNV>;
pub type PFN_vkCmdBuildMicromapsEXT = Option<NonNullPFN_vkCmdBuildMicromapsEXT>;
pub type PFN_vkCmdBuildPartitionedAccelerationStructuresNV = Option<NonNullPFN_vkCmdBuildPartitionedAccelerationStructuresNV>;
pub type PFN_vkCmdClearAttachments = Option<NonNullPFN_vkCmdClearAttachments>;
pub type PFN_vkCmdClearColorImage = Option<NonNullPFN_vkCmdClearColorImage>;
pub type PFN_vkCmdClearDepthStencilImage = Option<NonNullPFN_vkCmdClearDepthStencilImage>;
pub type PFN_vkCmdControlVideoCodingKHR = Option<NonNullPFN_vkCmdControlVideoCodingKHR>;
pub type PFN_vkCmdConvertCooperativeVectorMatrixNV = Option<NonNullPFN_vkCmdConvertCooperativeVectorMatrixNV>;
pub type PFN_vkCmdCopyAccelerationStructureKHR = Option<NonNullPFN_vkCmdCopyAccelerationStructureKHR>;
pub type PFN_vkCmdCopyAccelerationStructureNV = Option<NonNullPFN_vkCmdCopyAccelerationStructureNV>;
pub type PFN_vkCmdCopyAccelerationStructureToMemoryKHR = Option<NonNullPFN_vkCmdCopyAccelerationStructureToMemoryKHR>;
pub type PFN_vkCmdCopyBuffer = Option<NonNullPFN_vkCmdCopyBuffer>;
pub type PFN_vkCmdCopyBuffer2 = Option<NonNullPFN_vkCmdCopyBuffer2>;
pub type PFN_vkCmdCopyBuffer2KHR = Option<NonNullPFN_vkCmdCopyBuffer2KHR>;
pub type PFN_vkCmdCopyBufferToImage = Option<NonNullPFN_vkCmdCopyBufferToImage>;
pub type PFN_vkCmdCopyBufferToImage2 = Option<NonNullPFN_vkCmdCopyBufferToImage2>;
pub type PFN_vkCmdCopyBufferToImage2KHR = Option<NonNullPFN_vkCmdCopyBufferToImage2KHR>;
pub type PFN_vkCmdCopyImage = Option<NonNullPFN_vkCmdCopyImage>;
pub type PFN_vkCmdCopyImage2 = Option<NonNullPFN_vkCmdCopyImage2>;
pub type PFN_vkCmdCopyImage2KHR = Option<NonNullPFN_vkCmdCopyImage2KHR>;
pub type PFN_vkCmdCopyImageToBuffer = Option<NonNullPFN_vkCmdCopyImageToBuffer>;
pub type PFN_vkCmdCopyImageToBuffer2 = Option<NonNullPFN_vkCmdCopyImageToBuffer2>;
pub type PFN_vkCmdCopyImageToBuffer2KHR = Option<NonNullPFN_vkCmdCopyImageToBuffer2KHR>;
pub type PFN_vkCmdCopyMemoryIndirectKHR = Option<NonNullPFN_vkCmdCopyMemoryIndirectKHR>;
pub type PFN_vkCmdCopyMemoryIndirectNV = Option<NonNullPFN_vkCmdCopyMemoryIndirectNV>;
pub type PFN_vkCmdCopyMemoryToAccelerationStructureKHR = Option<NonNullPFN_vkCmdCopyMemoryToAccelerationStructureKHR>;
pub type PFN_vkCmdCopyMemoryToImageIndirectKHR = Option<NonNullPFN_vkCmdCopyMemoryToImageIndirectKHR>;
pub type PFN_vkCmdCopyMemoryToImageIndirectNV = Option<NonNullPFN_vkCmdCopyMemoryToImageIndirectNV>;
pub type PFN_vkCmdCopyMemoryToMicromapEXT = Option<NonNullPFN_vkCmdCopyMemoryToMicromapEXT>;
pub type PFN_vkCmdCopyMicromapEXT = Option<NonNullPFN_vkCmdCopyMicromapEXT>;
pub type PFN_vkCmdCopyMicromapToMemoryEXT = Option<NonNullPFN_vkCmdCopyMicromapToMemoryEXT>;
pub type PFN_vkCmdCopyQueryPoolResults = Option<NonNullPFN_vkCmdCopyQueryPoolResults>;
pub type PFN_vkCmdCopyTensorARM = Option<NonNullPFN_vkCmdCopyTensorARM>;
pub type PFN_vkCmdCuLaunchKernelNVX = Option<NonNullPFN_vkCmdCuLaunchKernelNVX>;
pub type PFN_vkCmdDebugMarkerBeginEXT = Option<NonNullPFN_vkCmdDebugMarkerBeginEXT>;
pub type PFN_vkCmdDebugMarkerEndEXT = Option<NonNullPFN_vkCmdDebugMarkerEndEXT>;
pub type PFN_vkCmdDebugMarkerInsertEXT = Option<NonNullPFN_vkCmdDebugMarkerInsertEXT>;
pub type PFN_vkCmdDecodeVideoKHR = Option<NonNullPFN_vkCmdDecodeVideoKHR>;
pub type PFN_vkCmdDecompressMemoryEXT = Option<NonNullPFN_vkCmdDecompressMemoryEXT>;
pub type PFN_vkCmdDecompressMemoryIndirectCountEXT = Option<NonNullPFN_vkCmdDecompressMemoryIndirectCountEXT>;
pub type PFN_vkCmdDecompressMemoryIndirectCountNV = Option<NonNullPFN_vkCmdDecompressMemoryIndirectCountNV>;
pub type PFN_vkCmdDecompressMemoryNV = Option<NonNullPFN_vkCmdDecompressMemoryNV>;
pub type PFN_vkCmdDispatch = Option<NonNullPFN_vkCmdDispatch>;
pub type PFN_vkCmdDispatchBase = Option<NonNullPFN_vkCmdDispatchBase>;
pub type PFN_vkCmdDispatchBaseKHR = Option<NonNullPFN_vkCmdDispatchBaseKHR>;
pub type PFN_vkCmdDispatchDataGraphARM = Option<NonNullPFN_vkCmdDispatchDataGraphARM>;
pub type PFN_vkCmdDispatchIndirect = Option<NonNullPFN_vkCmdDispatchIndirect>;
pub type PFN_vkCmdDispatchTileQCOM = Option<NonNullPFN_vkCmdDispatchTileQCOM>;
pub type PFN_vkCmdDraw = Option<NonNullPFN_vkCmdDraw>;
pub type PFN_vkCmdDrawClusterHUAWEI = Option<NonNullPFN_vkCmdDrawClusterHUAWEI>;
pub type PFN_vkCmdDrawClusterIndirectHUAWEI = Option<NonNullPFN_vkCmdDrawClusterIndirectHUAWEI>;
pub type PFN_vkCmdDrawIndexed = Option<NonNullPFN_vkCmdDrawIndexed>;
pub type PFN_vkCmdDrawIndexedIndirect = Option<NonNullPFN_vkCmdDrawIndexedIndirect>;
pub type PFN_vkCmdDrawIndexedIndirectCount = Option<NonNullPFN_vkCmdDrawIndexedIndirectCount>;
pub type PFN_vkCmdDrawIndexedIndirectCountAMD = Option<NonNullPFN_vkCmdDrawIndexedIndirectCountAMD>;
pub type PFN_vkCmdDrawIndexedIndirectCountKHR = Option<NonNullPFN_vkCmdDrawIndexedIndirectCountKHR>;
pub type PFN_vkCmdDrawIndirect = Option<NonNullPFN_vkCmdDrawIndirect>;
pub type PFN_vkCmdDrawIndirectByteCountEXT = Option<NonNullPFN_vkCmdDrawIndirectByteCountEXT>;
pub type PFN_vkCmdDrawIndirectCount = Option<NonNullPFN_vkCmdDrawIndirectCount>;
pub type PFN_vkCmdDrawIndirectCountAMD = Option<NonNullPFN_vkCmdDrawIndirectCountAMD>;
pub type PFN_vkCmdDrawIndirectCountKHR = Option<NonNullPFN_vkCmdDrawIndirectCountKHR>;
pub type PFN_vkCmdDrawMeshTasksEXT = Option<NonNullPFN_vkCmdDrawMeshTasksEXT>;
pub type PFN_vkCmdDrawMeshTasksIndirectCountEXT = Option<NonNullPFN_vkCmdDrawMeshTasksIndirectCountEXT>;
pub type PFN_vkCmdDrawMeshTasksIndirectCountNV = Option<NonNullPFN_vkCmdDrawMeshTasksIndirectCountNV>;
pub type PFN_vkCmdDrawMeshTasksIndirectEXT = Option<NonNullPFN_vkCmdDrawMeshTasksIndirectEXT>;
pub type PFN_vkCmdDrawMeshTasksIndirectNV = Option<NonNullPFN_vkCmdDrawMeshTasksIndirectNV>;
pub type PFN_vkCmdDrawMeshTasksNV = Option<NonNullPFN_vkCmdDrawMeshTasksNV>;
pub type PFN_vkCmdDrawMultiEXT = Option<NonNullPFN_vkCmdDrawMultiEXT>;
pub type PFN_vkCmdDrawMultiIndexedEXT = Option<NonNullPFN_vkCmdDrawMultiIndexedEXT>;
pub type PFN_vkCmdEncodeVideoKHR = Option<NonNullPFN_vkCmdEncodeVideoKHR>;
pub type PFN_vkCmdEndConditionalRenderingEXT = Option<NonNullPFN_vkCmdEndConditionalRenderingEXT>;
pub type PFN_vkCmdEndDebugUtilsLabelEXT = Option<NonNullPFN_vkCmdEndDebugUtilsLabelEXT>;
pub type PFN_vkCmdEndPerTileExecutionQCOM = Option<NonNullPFN_vkCmdEndPerTileExecutionQCOM>;
pub type PFN_vkCmdEndQuery = Option<NonNullPFN_vkCmdEndQuery>;
pub type PFN_vkCmdEndQueryIndexedEXT = Option<NonNullPFN_vkCmdEndQueryIndexedEXT>;
pub type PFN_vkCmdEndRenderPass = Option<NonNullPFN_vkCmdEndRenderPass>;
pub type PFN_vkCmdEndRenderPass2 = Option<NonNullPFN_vkCmdEndRenderPass2>;
pub type PFN_vkCmdEndRenderPass2KHR = Option<NonNullPFN_vkCmdEndRenderPass2KHR>;
pub type PFN_vkCmdEndRendering = Option<NonNullPFN_vkCmdEndRendering>;
pub type PFN_vkCmdEndRendering2EXT = Option<NonNullPFN_vkCmdEndRendering2EXT>;
pub type PFN_vkCmdEndRendering2KHR = Option<NonNullPFN_vkCmdEndRendering2KHR>;
pub type PFN_vkCmdEndRenderingKHR = Option<NonNullPFN_vkCmdEndRenderingKHR>;
pub type PFN_vkCmdEndTransformFeedbackEXT = Option<NonNullPFN_vkCmdEndTransformFeedbackEXT>;
pub type PFN_vkCmdEndVideoCodingKHR = Option<NonNullPFN_vkCmdEndVideoCodingKHR>;
pub type PFN_vkCmdExecuteCommands = Option<NonNullPFN_vkCmdExecuteCommands>;
pub type PFN_vkCmdExecuteGeneratedCommandsEXT = Option<NonNullPFN_vkCmdExecuteGeneratedCommandsEXT>;
pub type PFN_vkCmdExecuteGeneratedCommandsNV = Option<NonNullPFN_vkCmdExecuteGeneratedCommandsNV>;
pub type PFN_vkCmdFillBuffer = Option<NonNullPFN_vkCmdFillBuffer>;
pub type PFN_vkCmdInsertDebugUtilsLabelEXT = Option<NonNullPFN_vkCmdInsertDebugUtilsLabelEXT>;
pub type PFN_vkCmdNextSubpass = Option<NonNullPFN_vkCmdNextSubpass>;
pub type PFN_vkCmdNextSubpass2 = Option<NonNullPFN_vkCmdNextSubpass2>;
pub type PFN_vkCmdNextSubpass2KHR = Option<NonNullPFN_vkCmdNextSubpass2KHR>;
pub type PFN_vkCmdOpticalFlowExecuteNV = Option<NonNullPFN_vkCmdOpticalFlowExecuteNV>;
pub type PFN_vkCmdPipelineBarrier = Option<NonNullPFN_vkCmdPipelineBarrier>;
pub type PFN_vkCmdPipelineBarrier2 = Option<NonNullPFN_vkCmdPipelineBarrier2>;
pub type PFN_vkCmdPipelineBarrier2KHR = Option<NonNullPFN_vkCmdPipelineBarrier2KHR>;
pub type PFN_vkCmdPreprocessGeneratedCommandsEXT = Option<NonNullPFN_vkCmdPreprocessGeneratedCommandsEXT>;
pub type PFN_vkCmdPreprocessGeneratedCommandsNV = Option<NonNullPFN_vkCmdPreprocessGeneratedCommandsNV>;
pub type PFN_vkCmdPushConstants = Option<NonNullPFN_vkCmdPushConstants>;
pub type PFN_vkCmdPushConstants2 = Option<NonNullPFN_vkCmdPushConstants2>;
pub type PFN_vkCmdPushConstants2KHR = Option<NonNullPFN_vkCmdPushConstants2KHR>;
pub type PFN_vkCmdPushDescriptorSet = Option<NonNullPFN_vkCmdPushDescriptorSet>;
pub type PFN_vkCmdPushDescriptorSet2 = Option<NonNullPFN_vkCmdPushDescriptorSet2>;
pub type PFN_vkCmdPushDescriptorSet2KHR = Option<NonNullPFN_vkCmdPushDescriptorSet2KHR>;
pub type PFN_vkCmdPushDescriptorSetKHR = Option<NonNullPFN_vkCmdPushDescriptorSetKHR>;
pub type PFN_vkCmdPushDescriptorSetWithTemplate = Option<NonNullPFN_vkCmdPushDescriptorSetWithTemplate>;
pub type PFN_vkCmdPushDescriptorSetWithTemplate2 = Option<NonNullPFN_vkCmdPushDescriptorSetWithTemplate2>;
pub type PFN_vkCmdPushDescriptorSetWithTemplate2KHR = Option<NonNullPFN_vkCmdPushDescriptorSetWithTemplate2KHR>;
pub type PFN_vkCmdPushDescriptorSetWithTemplateKHR = Option<NonNullPFN_vkCmdPushDescriptorSetWithTemplateKHR>;
pub type PFN_vkCmdResetEvent = Option<NonNullPFN_vkCmdResetEvent>;
pub type PFN_vkCmdResetEvent2 = Option<NonNullPFN_vkCmdResetEvent2>;
pub type PFN_vkCmdResetEvent2KHR = Option<NonNullPFN_vkCmdResetEvent2KHR>;
pub type PFN_vkCmdResetQueryPool = Option<NonNullPFN_vkCmdResetQueryPool>;
pub type PFN_vkCmdResolveImage = Option<NonNullPFN_vkCmdResolveImage>;
pub type PFN_vkCmdResolveImage2 = Option<NonNullPFN_vkCmdResolveImage2>;
pub type PFN_vkCmdResolveImage2KHR = Option<NonNullPFN_vkCmdResolveImage2KHR>;
pub type PFN_vkCmdSetAlphaToCoverageEnableEXT = Option<NonNullPFN_vkCmdSetAlphaToCoverageEnableEXT>;
pub type PFN_vkCmdSetAlphaToOneEnableEXT = Option<NonNullPFN_vkCmdSetAlphaToOneEnableEXT>;
pub type PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT = Option<NonNullPFN_vkCmdSetAttachmentFeedbackLoopEnableEXT>;
pub type PFN_vkCmdSetBlendConstants = Option<NonNullPFN_vkCmdSetBlendConstants>;
pub type PFN_vkCmdSetCheckpointNV = Option<NonNullPFN_vkCmdSetCheckpointNV>;
pub type PFN_vkCmdSetCoarseSampleOrderNV = Option<NonNullPFN_vkCmdSetCoarseSampleOrderNV>;
pub type PFN_vkCmdSetColorBlendAdvancedEXT = Option<NonNullPFN_vkCmdSetColorBlendAdvancedEXT>;
pub type PFN_vkCmdSetColorBlendEnableEXT = Option<NonNullPFN_vkCmdSetColorBlendEnableEXT>;
pub type PFN_vkCmdSetColorBlendEquationEXT = Option<NonNullPFN_vkCmdSetColorBlendEquationEXT>;
pub type PFN_vkCmdSetColorWriteEnableEXT = Option<NonNullPFN_vkCmdSetColorWriteEnableEXT>;
pub type PFN_vkCmdSetColorWriteMaskEXT = Option<NonNullPFN_vkCmdSetColorWriteMaskEXT>;
pub type PFN_vkCmdSetComputeOccupancyPriorityNV = Option<NonNullPFN_vkCmdSetComputeOccupancyPriorityNV>;
pub type PFN_vkCmdSetConservativeRasterizationModeEXT = Option<NonNullPFN_vkCmdSetConservativeRasterizationModeEXT>;
pub type PFN_vkCmdSetCoverageModulationModeNV = Option<NonNullPFN_vkCmdSetCoverageModulationModeNV>;
pub type PFN_vkCmdSetCoverageModulationTableEnableNV = Option<NonNullPFN_vkCmdSetCoverageModulationTableEnableNV>;
pub type PFN_vkCmdSetCoverageModulationTableNV = Option<NonNullPFN_vkCmdSetCoverageModulationTableNV>;
pub type PFN_vkCmdSetCoverageReductionModeNV = Option<NonNullPFN_vkCmdSetCoverageReductionModeNV>;
pub type PFN_vkCmdSetCoverageToColorEnableNV = Option<NonNullPFN_vkCmdSetCoverageToColorEnableNV>;
pub type PFN_vkCmdSetCoverageToColorLocationNV = Option<NonNullPFN_vkCmdSetCoverageToColorLocationNV>;
pub type PFN_vkCmdSetCullMode = Option<NonNullPFN_vkCmdSetCullMode>;
pub type PFN_vkCmdSetCullModeEXT = Option<NonNullPFN_vkCmdSetCullModeEXT>;
pub type PFN_vkCmdSetDepthBias = Option<NonNullPFN_vkCmdSetDepthBias>;
pub type PFN_vkCmdSetDepthBias2EXT = Option<NonNullPFN_vkCmdSetDepthBias2EXT>;
pub type PFN_vkCmdSetDepthBiasEnable = Option<NonNullPFN_vkCmdSetDepthBiasEnable>;
pub type PFN_vkCmdSetDepthBiasEnableEXT = Option<NonNullPFN_vkCmdSetDepthBiasEnableEXT>;
pub type PFN_vkCmdSetDepthBounds = Option<NonNullPFN_vkCmdSetDepthBounds>;
pub type PFN_vkCmdSetDepthBoundsTestEnable = Option<NonNullPFN_vkCmdSetDepthBoundsTestEnable>;
pub type PFN_vkCmdSetDepthBoundsTestEnableEXT = Option<NonNullPFN_vkCmdSetDepthBoundsTestEnableEXT>;
pub type PFN_vkCmdSetDepthClampEnableEXT = Option<NonNullPFN_vkCmdSetDepthClampEnableEXT>;
pub type PFN_vkCmdSetDepthClampRangeEXT = Option<NonNullPFN_vkCmdSetDepthClampRangeEXT>;
pub type PFN_vkCmdSetDepthClipEnableEXT = Option<NonNullPFN_vkCmdSetDepthClipEnableEXT>;
pub type PFN_vkCmdSetDepthClipNegativeOneToOneEXT = Option<NonNullPFN_vkCmdSetDepthClipNegativeOneToOneEXT>;
pub type PFN_vkCmdSetDepthCompareOp = Option<NonNullPFN_vkCmdSetDepthCompareOp>;
pub type PFN_vkCmdSetDepthCompareOpEXT = Option<NonNullPFN_vkCmdSetDepthCompareOpEXT>;
pub type PFN_vkCmdSetDepthTestEnable = Option<NonNullPFN_vkCmdSetDepthTestEnable>;
pub type PFN_vkCmdSetDepthTestEnableEXT = Option<NonNullPFN_vkCmdSetDepthTestEnableEXT>;
pub type PFN_vkCmdSetDepthWriteEnable = Option<NonNullPFN_vkCmdSetDepthWriteEnable>;
pub type PFN_vkCmdSetDepthWriteEnableEXT = Option<NonNullPFN_vkCmdSetDepthWriteEnableEXT>;
pub type PFN_vkCmdSetDescriptorBufferOffsets2EXT = Option<NonNullPFN_vkCmdSetDescriptorBufferOffsets2EXT>;
pub type PFN_vkCmdSetDescriptorBufferOffsetsEXT = Option<NonNullPFN_vkCmdSetDescriptorBufferOffsetsEXT>;
pub type PFN_vkCmdSetDeviceMask = Option<NonNullPFN_vkCmdSetDeviceMask>;
pub type PFN_vkCmdSetDeviceMaskKHR = Option<NonNullPFN_vkCmdSetDeviceMaskKHR>;
pub type PFN_vkCmdSetDiscardRectangleEXT = Option<NonNullPFN_vkCmdSetDiscardRectangleEXT>;
pub type PFN_vkCmdSetDiscardRectangleEnableEXT = Option<NonNullPFN_vkCmdSetDiscardRectangleEnableEXT>;
pub type PFN_vkCmdSetDiscardRectangleModeEXT = Option<NonNullPFN_vkCmdSetDiscardRectangleModeEXT>;
pub type PFN_vkCmdSetEvent = Option<NonNullPFN_vkCmdSetEvent>;
pub type PFN_vkCmdSetEvent2 = Option<NonNullPFN_vkCmdSetEvent2>;
pub type PFN_vkCmdSetEvent2KHR = Option<NonNullPFN_vkCmdSetEvent2KHR>;
pub type PFN_vkCmdSetExclusiveScissorEnableNV = Option<NonNullPFN_vkCmdSetExclusiveScissorEnableNV>;
pub type PFN_vkCmdSetExclusiveScissorNV = Option<NonNullPFN_vkCmdSetExclusiveScissorNV>;
pub type PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT = Option<NonNullPFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT>;
pub type PFN_vkCmdSetFragmentShadingRateEnumNV = Option<NonNullPFN_vkCmdSetFragmentShadingRateEnumNV>;
pub type PFN_vkCmdSetFragmentShadingRateKHR = Option<NonNullPFN_vkCmdSetFragmentShadingRateKHR>;
pub type PFN_vkCmdSetFrontFace = Option<NonNullPFN_vkCmdSetFrontFace>;
pub type PFN_vkCmdSetFrontFaceEXT = Option<NonNullPFN_vkCmdSetFrontFaceEXT>;
pub type PFN_vkCmdSetLineRasterizationModeEXT = Option<NonNullPFN_vkCmdSetLineRasterizationModeEXT>;
pub type PFN_vkCmdSetLineStipple = Option<NonNullPFN_vkCmdSetLineStipple>;
pub type PFN_vkCmdSetLineStippleEXT = Option<NonNullPFN_vkCmdSetLineStippleEXT>;
pub type PFN_vkCmdSetLineStippleEnableEXT = Option<NonNullPFN_vkCmdSetLineStippleEnableEXT>;
pub type PFN_vkCmdSetLineStippleKHR = Option<NonNullPFN_vkCmdSetLineStippleKHR>;
pub type PFN_vkCmdSetLineWidth = Option<NonNullPFN_vkCmdSetLineWidth>;
pub type PFN_vkCmdSetLogicOpEXT = Option<NonNullPFN_vkCmdSetLogicOpEXT>;
pub type PFN_vkCmdSetLogicOpEnableEXT = Option<NonNullPFN_vkCmdSetLogicOpEnableEXT>;
pub type PFN_vkCmdSetPatchControlPointsEXT = Option<NonNullPFN_vkCmdSetPatchControlPointsEXT>;
pub type PFN_vkCmdSetPerformanceMarkerINTEL = Option<NonNullPFN_vkCmdSetPerformanceMarkerINTEL>;
pub type PFN_vkCmdSetPerformanceOverrideINTEL = Option<NonNullPFN_vkCmdSetPerformanceOverrideINTEL>;
pub type PFN_vkCmdSetPerformanceStreamMarkerINTEL = Option<NonNullPFN_vkCmdSetPerformanceStreamMarkerINTEL>;
pub type PFN_vkCmdSetPolygonModeEXT = Option<NonNullPFN_vkCmdSetPolygonModeEXT>;
pub type PFN_vkCmdSetPrimitiveRestartEnable = Option<NonNullPFN_vkCmdSetPrimitiveRestartEnable>;
pub type PFN_vkCmdSetPrimitiveRestartEnableEXT = Option<NonNullPFN_vkCmdSetPrimitiveRestartEnableEXT>;
pub type PFN_vkCmdSetPrimitiveTopology = Option<NonNullPFN_vkCmdSetPrimitiveTopology>;
pub type PFN_vkCmdSetPrimitiveTopologyEXT = Option<NonNullPFN_vkCmdSetPrimitiveTopologyEXT>;
pub type PFN_vkCmdSetProvokingVertexModeEXT = Option<NonNullPFN_vkCmdSetProvokingVertexModeEXT>;
pub type PFN_vkCmdSetRasterizationSamplesEXT = Option<NonNullPFN_vkCmdSetRasterizationSamplesEXT>;
pub type PFN_vkCmdSetRasterizationStreamEXT = Option<NonNullPFN_vkCmdSetRasterizationStreamEXT>;
pub type PFN_vkCmdSetRasterizerDiscardEnable = Option<NonNullPFN_vkCmdSetRasterizerDiscardEnable>;
pub type PFN_vkCmdSetRasterizerDiscardEnableEXT = Option<NonNullPFN_vkCmdSetRasterizerDiscardEnableEXT>;
pub type PFN_vkCmdSetRayTracingPipelineStackSizeKHR = Option<NonNullPFN_vkCmdSetRayTracingPipelineStackSizeKHR>;
pub type PFN_vkCmdSetRenderingAttachmentLocations = Option<NonNullPFN_vkCmdSetRenderingAttachmentLocations>;
pub type PFN_vkCmdSetRenderingAttachmentLocationsKHR = Option<NonNullPFN_vkCmdSetRenderingAttachmentLocationsKHR>;
pub type PFN_vkCmdSetRenderingInputAttachmentIndices = Option<NonNullPFN_vkCmdSetRenderingInputAttachmentIndices>;
pub type PFN_vkCmdSetRenderingInputAttachmentIndicesKHR = Option<NonNullPFN_vkCmdSetRenderingInputAttachmentIndicesKHR>;
pub type PFN_vkCmdSetRepresentativeFragmentTestEnableNV = Option<NonNullPFN_vkCmdSetRepresentativeFragmentTestEnableNV>;
pub type PFN_vkCmdSetSampleLocationsEXT = Option<NonNullPFN_vkCmdSetSampleLocationsEXT>;
pub type PFN_vkCmdSetSampleLocationsEnableEXT = Option<NonNullPFN_vkCmdSetSampleLocationsEnableEXT>;
pub type PFN_vkCmdSetSampleMaskEXT = Option<NonNullPFN_vkCmdSetSampleMaskEXT>;
pub type PFN_vkCmdSetScissor = Option<NonNullPFN_vkCmdSetScissor>;
pub type PFN_vkCmdSetScissorWithCount = Option<NonNullPFN_vkCmdSetScissorWithCount>;
pub type PFN_vkCmdSetScissorWithCountEXT = Option<NonNullPFN_vkCmdSetScissorWithCountEXT>;
pub type PFN_vkCmdSetShadingRateImageEnableNV = Option<NonNullPFN_vkCmdSetShadingRateImageEnableNV>;
pub type PFN_vkCmdSetStencilCompareMask = Option<NonNullPFN_vkCmdSetStencilCompareMask>;
pub type PFN_vkCmdSetStencilOp = Option<NonNullPFN_vkCmdSetStencilOp>;
pub type PFN_vkCmdSetStencilOpEXT = Option<NonNullPFN_vkCmdSetStencilOpEXT>;
pub type PFN_vkCmdSetStencilReference = Option<NonNullPFN_vkCmdSetStencilReference>;
pub type PFN_vkCmdSetStencilTestEnable = Option<NonNullPFN_vkCmdSetStencilTestEnable>;
pub type PFN_vkCmdSetStencilTestEnableEXT = Option<NonNullPFN_vkCmdSetStencilTestEnableEXT>;
pub type PFN_vkCmdSetStencilWriteMask = Option<NonNullPFN_vkCmdSetStencilWriteMask>;
pub type PFN_vkCmdSetTessellationDomainOriginEXT = Option<NonNullPFN_vkCmdSetTessellationDomainOriginEXT>;
pub type PFN_vkCmdSetVertexInputEXT = Option<NonNullPFN_vkCmdSetVertexInputEXT>;
pub type PFN_vkCmdSetViewport = Option<NonNullPFN_vkCmdSetViewport>;
pub type PFN_vkCmdSetViewportShadingRatePaletteNV = Option<NonNullPFN_vkCmdSetViewportShadingRatePaletteNV>;
pub type PFN_vkCmdSetViewportSwizzleNV = Option<NonNullPFN_vkCmdSetViewportSwizzleNV>;
pub type PFN_vkCmdSetViewportWScalingEnableNV = Option<NonNullPFN_vkCmdSetViewportWScalingEnableNV>;
pub type PFN_vkCmdSetViewportWScalingNV = Option<NonNullPFN_vkCmdSetViewportWScalingNV>;
pub type PFN_vkCmdSetViewportWithCount = Option<NonNullPFN_vkCmdSetViewportWithCount>;
pub type PFN_vkCmdSetViewportWithCountEXT = Option<NonNullPFN_vkCmdSetViewportWithCountEXT>;
pub type PFN_vkCmdSubpassShadingHUAWEI = Option<NonNullPFN_vkCmdSubpassShadingHUAWEI>;
pub type PFN_vkCmdTraceRaysIndirect2KHR = Option<NonNullPFN_vkCmdTraceRaysIndirect2KHR>;
pub type PFN_vkCmdTraceRaysIndirectKHR = Option<NonNullPFN_vkCmdTraceRaysIndirectKHR>;
pub type PFN_vkCmdTraceRaysKHR = Option<NonNullPFN_vkCmdTraceRaysKHR>;
pub type PFN_vkCmdTraceRaysNV = Option<NonNullPFN_vkCmdTraceRaysNV>;
pub type PFN_vkCmdUpdateBuffer = Option<NonNullPFN_vkCmdUpdateBuffer>;
pub type PFN_vkCmdUpdatePipelineIndirectBufferNV = Option<NonNullPFN_vkCmdUpdatePipelineIndirectBufferNV>;
pub type PFN_vkCmdWaitEvents = Option<NonNullPFN_vkCmdWaitEvents>;
pub type PFN_vkCmdWaitEvents2 = Option<NonNullPFN_vkCmdWaitEvents2>;
pub type PFN_vkCmdWaitEvents2KHR = Option<NonNullPFN_vkCmdWaitEvents2KHR>;
pub type PFN_vkCmdWriteAccelerationStructuresPropertiesKHR = Option<NonNullPFN_vkCmdWriteAccelerationStructuresPropertiesKHR>;
pub type PFN_vkCmdWriteAccelerationStructuresPropertiesNV = Option<NonNullPFN_vkCmdWriteAccelerationStructuresPropertiesNV>;
pub type PFN_vkCmdWriteBufferMarker2AMD = Option<NonNullPFN_vkCmdWriteBufferMarker2AMD>;
pub type PFN_vkCmdWriteBufferMarkerAMD = Option<NonNullPFN_vkCmdWriteBufferMarkerAMD>;
pub type PFN_vkCmdWriteMicromapsPropertiesEXT = Option<NonNullPFN_vkCmdWriteMicromapsPropertiesEXT>;
pub type PFN_vkCmdWriteTimestamp = Option<NonNullPFN_vkCmdWriteTimestamp>;
pub type PFN_vkCmdWriteTimestamp2 = Option<NonNullPFN_vkCmdWriteTimestamp2>;
pub type PFN_vkCmdWriteTimestamp2KHR = Option<NonNullPFN_vkCmdWriteTimestamp2KHR>;
pub type PFN_vkCompileDeferredNV = Option<NonNullPFN_vkCompileDeferredNV>;
pub type PFN_vkConvertCooperativeVectorMatrixNV = Option<NonNullPFN_vkConvertCooperativeVectorMatrixNV>;
pub type PFN_vkCopyAccelerationStructureKHR = Option<NonNullPFN_vkCopyAccelerationStructureKHR>;
pub type PFN_vkCopyAccelerationStructureToMemoryKHR = Option<NonNullPFN_vkCopyAccelerationStructureToMemoryKHR>;
pub type PFN_vkCopyImageToImage = Option<NonNullPFN_vkCopyImageToImage>;
pub type PFN_vkCopyImageToImageEXT = Option<NonNullPFN_vkCopyImageToImageEXT>;
pub type PFN_vkCopyImageToMemory = Option<NonNullPFN_vkCopyImageToMemory>;
pub type PFN_vkCopyImageToMemoryEXT = Option<NonNullPFN_vkCopyImageToMemoryEXT>;
pub type PFN_vkCopyMemoryToAccelerationStructureKHR = Option<NonNullPFN_vkCopyMemoryToAccelerationStructureKHR>;
pub type PFN_vkCopyMemoryToImage = Option<NonNullPFN_vkCopyMemoryToImage>;
pub type PFN_vkCopyMemoryToImageEXT = Option<NonNullPFN_vkCopyMemoryToImageEXT>;
pub type PFN_vkCopyMemoryToMicromapEXT = Option<NonNullPFN_vkCopyMemoryToMicromapEXT>;
pub type PFN_vkCopyMicromapEXT = Option<NonNullPFN_vkCopyMicromapEXT>;
pub type PFN_vkCopyMicromapToMemoryEXT = Option<NonNullPFN_vkCopyMicromapToMemoryEXT>;
pub type PFN_vkCreateAccelerationStructureKHR = Option<NonNullPFN_vkCreateAccelerationStructureKHR>;
pub type PFN_vkCreateAccelerationStructureNV = Option<NonNullPFN_vkCreateAccelerationStructureNV>;
pub type PFN_vkCreateBuffer = Option<NonNullPFN_vkCreateBuffer>;
pub type PFN_vkCreateBufferView = Option<NonNullPFN_vkCreateBufferView>;
pub type PFN_vkCreateCommandPool = Option<NonNullPFN_vkCreateCommandPool>;
pub type PFN_vkCreateComputePipelines = Option<NonNullPFN_vkCreateComputePipelines>;
pub type PFN_vkCreateCuFunctionNVX = Option<NonNullPFN_vkCreateCuFunctionNVX>;
pub type PFN_vkCreateCuModuleNVX = Option<NonNullPFN_vkCreateCuModuleNVX>;
pub type PFN_vkCreateDataGraphPipelineSessionARM = Option<NonNullPFN_vkCreateDataGraphPipelineSessionARM>;
pub type PFN_vkCreateDataGraphPipelinesARM = Option<NonNullPFN_vkCreateDataGraphPipelinesARM>;
pub type PFN_vkCreateDebugReportCallbackEXT = Option<NonNullPFN_vkCreateDebugReportCallbackEXT>;
pub type PFN_vkCreateDebugUtilsMessengerEXT = Option<NonNullPFN_vkCreateDebugUtilsMessengerEXT>;
pub type PFN_vkCreateDeferredOperationKHR = Option<NonNullPFN_vkCreateDeferredOperationKHR>;
pub type PFN_vkCreateDescriptorPool = Option<NonNullPFN_vkCreateDescriptorPool>;
pub type PFN_vkCreateDescriptorSetLayout = Option<NonNullPFN_vkCreateDescriptorSetLayout>;
pub type PFN_vkCreateDescriptorUpdateTemplate = Option<NonNullPFN_vkCreateDescriptorUpdateTemplate>;
pub type PFN_vkCreateDescriptorUpdateTemplateKHR = Option<NonNullPFN_vkCreateDescriptorUpdateTemplateKHR>;
pub type PFN_vkCreateDevice = Option<NonNullPFN_vkCreateDevice>;
pub type PFN_vkCreateDisplayModeKHR = Option<NonNullPFN_vkCreateDisplayModeKHR>;
pub type PFN_vkCreateDisplayPlaneSurfaceKHR = Option<NonNullPFN_vkCreateDisplayPlaneSurfaceKHR>;
pub type PFN_vkCreateEvent = Option<NonNullPFN_vkCreateEvent>;
pub type PFN_vkCreateExternalComputeQueueNV = Option<NonNullPFN_vkCreateExternalComputeQueueNV>;
pub type PFN_vkCreateFence = Option<NonNullPFN_vkCreateFence>;
pub type PFN_vkCreateFramebuffer = Option<NonNullPFN_vkCreateFramebuffer>;
pub type PFN_vkCreateGraphicsPipelines = Option<NonNullPFN_vkCreateGraphicsPipelines>;
pub type PFN_vkCreateHeadlessSurfaceEXT = Option<NonNullPFN_vkCreateHeadlessSurfaceEXT>;
pub type PFN_vkCreateImage = Option<NonNullPFN_vkCreateImage>;
pub type PFN_vkCreateImageView = Option<NonNullPFN_vkCreateImageView>;
pub type PFN_vkCreateIndirectCommandsLayoutEXT = Option<NonNullPFN_vkCreateIndirectCommandsLayoutEXT>;
pub type PFN_vkCreateIndirectCommandsLayoutNV = Option<NonNullPFN_vkCreateIndirectCommandsLayoutNV>;
pub type PFN_vkCreateIndirectExecutionSetEXT = Option<NonNullPFN_vkCreateIndirectExecutionSetEXT>;
pub type PFN_vkCreateInstance = Option<NonNullPFN_vkCreateInstance>;
pub type PFN_vkCreateMicromapEXT = Option<NonNullPFN_vkCreateMicromapEXT>;
pub type PFN_vkCreateOpticalFlowSessionNV = Option<NonNullPFN_vkCreateOpticalFlowSessionNV>;
pub type PFN_vkCreatePipelineBinariesKHR = Option<NonNullPFN_vkCreatePipelineBinariesKHR>;
pub type PFN_vkCreatePipelineCache = Option<NonNullPFN_vkCreatePipelineCache>;
pub type PFN_vkCreatePipelineLayout = Option<NonNullPFN_vkCreatePipelineLayout>;
pub type PFN_vkCreatePrivateDataSlot = Option<NonNullPFN_vkCreatePrivateDataSlot>;
pub type PFN_vkCreatePrivateDataSlotEXT = Option<NonNullPFN_vkCreatePrivateDataSlotEXT>;
pub type PFN_vkCreateQueryPool = Option<NonNullPFN_vkCreateQueryPool>;
pub type PFN_vkCreateRayTracingPipelinesKHR = Option<NonNullPFN_vkCreateRayTracingPipelinesKHR>;
pub type PFN_vkCreateRayTracingPipelinesNV = Option<NonNullPFN_vkCreateRayTracingPipelinesNV>;
pub type PFN_vkCreateRenderPass = Option<NonNullPFN_vkCreateRenderPass>;
pub type PFN_vkCreateRenderPass2 = Option<NonNullPFN_vkCreateRenderPass2>;
pub type PFN_vkCreateRenderPass2KHR = Option<NonNullPFN_vkCreateRenderPass2KHR>;
pub type PFN_vkCreateSampler = Option<NonNullPFN_vkCreateSampler>;
pub type PFN_vkCreateSamplerYcbcrConversion = Option<NonNullPFN_vkCreateSamplerYcbcrConversion>;
pub type PFN_vkCreateSamplerYcbcrConversionKHR = Option<NonNullPFN_vkCreateSamplerYcbcrConversionKHR>;
pub type PFN_vkCreateSemaphore = Option<NonNullPFN_vkCreateSemaphore>;
pub type PFN_vkCreateShaderModule = Option<NonNullPFN_vkCreateShaderModule>;
pub type PFN_vkCreateShadersEXT = Option<NonNullPFN_vkCreateShadersEXT>;
pub type PFN_vkCreateSharedSwapchainsKHR = Option<NonNullPFN_vkCreateSharedSwapchainsKHR>;
pub type PFN_vkCreateSwapchainKHR = Option<NonNullPFN_vkCreateSwapchainKHR>;
pub type PFN_vkCreateTensorARM = Option<NonNullPFN_vkCreateTensorARM>;
pub type PFN_vkCreateTensorViewARM = Option<NonNullPFN_vkCreateTensorViewARM>;
pub type PFN_vkCreateValidationCacheEXT = Option<NonNullPFN_vkCreateValidationCacheEXT>;
pub type PFN_vkCreateVideoSessionKHR = Option<NonNullPFN_vkCreateVideoSessionKHR>;
pub type PFN_vkCreateVideoSessionParametersKHR = Option<NonNullPFN_vkCreateVideoSessionParametersKHR>;
pub type PFN_vkDebugMarkerSetObjectNameEXT = Option<NonNullPFN_vkDebugMarkerSetObjectNameEXT>;
pub type PFN_vkDebugMarkerSetObjectTagEXT = Option<NonNullPFN_vkDebugMarkerSetObjectTagEXT>;
pub type PFN_vkDebugReportCallbackEXT = Option<NonNullPFN_vkDebugReportCallbackEXT>;
pub type PFN_vkDebugReportMessageEXT = Option<NonNullPFN_vkDebugReportMessageEXT>;
pub type PFN_vkDebugUtilsMessengerCallbackEXT = Option<NonNullPFN_vkDebugUtilsMessengerCallbackEXT>;
pub type PFN_vkDeferredOperationJoinKHR = Option<NonNullPFN_vkDeferredOperationJoinKHR>;
pub type PFN_vkDestroyAccelerationStructureKHR = Option<NonNullPFN_vkDestroyAccelerationStructureKHR>;
pub type PFN_vkDestroyAccelerationStructureNV = Option<NonNullPFN_vkDestroyAccelerationStructureNV>;
pub type PFN_vkDestroyBuffer = Option<NonNullPFN_vkDestroyBuffer>;
pub type PFN_vkDestroyBufferView = Option<NonNullPFN_vkDestroyBufferView>;
pub type PFN_vkDestroyCommandPool = Option<NonNullPFN_vkDestroyCommandPool>;
pub type PFN_vkDestroyCuFunctionNVX = Option<NonNullPFN_vkDestroyCuFunctionNVX>;
pub type PFN_vkDestroyCuModuleNVX = Option<NonNullPFN_vkDestroyCuModuleNVX>;
pub type PFN_vkDestroyDataGraphPipelineSessionARM = Option<NonNullPFN_vkDestroyDataGraphPipelineSessionARM>;
pub type PFN_vkDestroyDebugReportCallbackEXT = Option<NonNullPFN_vkDestroyDebugReportCallbackEXT>;
pub type PFN_vkDestroyDebugUtilsMessengerEXT = Option<NonNullPFN_vkDestroyDebugUtilsMessengerEXT>;
pub type PFN_vkDestroyDeferredOperationKHR = Option<NonNullPFN_vkDestroyDeferredOperationKHR>;
pub type PFN_vkDestroyDescriptorPool = Option<NonNullPFN_vkDestroyDescriptorPool>;
pub type PFN_vkDestroyDescriptorSetLayout = Option<NonNullPFN_vkDestroyDescriptorSetLayout>;
pub type PFN_vkDestroyDescriptorUpdateTemplate = Option<NonNullPFN_vkDestroyDescriptorUpdateTemplate>;
pub type PFN_vkDestroyDescriptorUpdateTemplateKHR = Option<NonNullPFN_vkDestroyDescriptorUpdateTemplateKHR>;
pub type PFN_vkDestroyDevice = Option<NonNullPFN_vkDestroyDevice>;
pub type PFN_vkDestroyEvent = Option<NonNullPFN_vkDestroyEvent>;
pub type PFN_vkDestroyExternalComputeQueueNV = Option<NonNullPFN_vkDestroyExternalComputeQueueNV>;
pub type PFN_vkDestroyFence = Option<NonNullPFN_vkDestroyFence>;
pub type PFN_vkDestroyFramebuffer = Option<NonNullPFN_vkDestroyFramebuffer>;
pub type PFN_vkDestroyImage = Option<NonNullPFN_vkDestroyImage>;
pub type PFN_vkDestroyImageView = Option<NonNullPFN_vkDestroyImageView>;
pub type PFN_vkDestroyIndirectCommandsLayoutEXT = Option<NonNullPFN_vkDestroyIndirectCommandsLayoutEXT>;
pub type PFN_vkDestroyIndirectCommandsLayoutNV = Option<NonNullPFN_vkDestroyIndirectCommandsLayoutNV>;
pub type PFN_vkDestroyIndirectExecutionSetEXT = Option<NonNullPFN_vkDestroyIndirectExecutionSetEXT>;
pub type PFN_vkDestroyInstance = Option<NonNullPFN_vkDestroyInstance>;
pub type PFN_vkDestroyMicromapEXT = Option<NonNullPFN_vkDestroyMicromapEXT>;
pub type PFN_vkDestroyOpticalFlowSessionNV = Option<NonNullPFN_vkDestroyOpticalFlowSessionNV>;
pub type PFN_vkDestroyPipeline = Option<NonNullPFN_vkDestroyPipeline>;
pub type PFN_vkDestroyPipelineBinaryKHR = Option<NonNullPFN_vkDestroyPipelineBinaryKHR>;
pub type PFN_vkDestroyPipelineCache = Option<NonNullPFN_vkDestroyPipelineCache>;
pub type PFN_vkDestroyPipelineLayout = Option<NonNullPFN_vkDestroyPipelineLayout>;
pub type PFN_vkDestroyPrivateDataSlot = Option<NonNullPFN_vkDestroyPrivateDataSlot>;
pub type PFN_vkDestroyPrivateDataSlotEXT = Option<NonNullPFN_vkDestroyPrivateDataSlotEXT>;
pub type PFN_vkDestroyQueryPool = Option<NonNullPFN_vkDestroyQueryPool>;
pub type PFN_vkDestroyRenderPass = Option<NonNullPFN_vkDestroyRenderPass>;
pub type PFN_vkDestroySampler = Option<NonNullPFN_vkDestroySampler>;
pub type PFN_vkDestroySamplerYcbcrConversion = Option<NonNullPFN_vkDestroySamplerYcbcrConversion>;
pub type PFN_vkDestroySamplerYcbcrConversionKHR = Option<NonNullPFN_vkDestroySamplerYcbcrConversionKHR>;
pub type PFN_vkDestroySemaphore = Option<NonNullPFN_vkDestroySemaphore>;
pub type PFN_vkDestroyShaderEXT = Option<NonNullPFN_vkDestroyShaderEXT>;
pub type PFN_vkDestroyShaderModule = Option<NonNullPFN_vkDestroyShaderModule>;
pub type PFN_vkDestroySurfaceKHR = Option<NonNullPFN_vkDestroySurfaceKHR>;
pub type PFN_vkDestroySwapchainKHR = Option<NonNullPFN_vkDestroySwapchainKHR>;
pub type PFN_vkDestroyTensorARM = Option<NonNullPFN_vkDestroyTensorARM>;
pub type PFN_vkDestroyTensorViewARM = Option<NonNullPFN_vkDestroyTensorViewARM>;
pub type PFN_vkDestroyValidationCacheEXT = Option<NonNullPFN_vkDestroyValidationCacheEXT>;
pub type PFN_vkDestroyVideoSessionKHR = Option<NonNullPFN_vkDestroyVideoSessionKHR>;
pub type PFN_vkDestroyVideoSessionParametersKHR = Option<NonNullPFN_vkDestroyVideoSessionParametersKHR>;
pub type PFN_vkDeviceMemoryReportCallbackEXT = Option<NonNullPFN_vkDeviceMemoryReportCallbackEXT>;
pub type PFN_vkDeviceWaitIdle = Option<NonNullPFN_vkDeviceWaitIdle>;
pub type PFN_vkDisplayPowerControlEXT = Option<NonNullPFN_vkDisplayPowerControlEXT>;
pub type PFN_vkEndCommandBuffer = Option<NonNullPFN_vkEndCommandBuffer>;
pub type PFN_vkEnumerateDeviceExtensionProperties = Option<NonNullPFN_vkEnumerateDeviceExtensionProperties>;
pub type PFN_vkEnumerateDeviceLayerProperties = Option<NonNullPFN_vkEnumerateDeviceLayerProperties>;
pub type PFN_vkEnumerateInstanceExtensionProperties = Option<NonNullPFN_vkEnumerateInstanceExtensionProperties>;
pub type PFN_vkEnumerateInstanceLayerProperties = Option<NonNullPFN_vkEnumerateInstanceLayerProperties>;
pub type PFN_vkEnumerateInstanceVersion = Option<NonNullPFN_vkEnumerateInstanceVersion>;
pub type PFN_vkEnumeratePhysicalDeviceGroups = Option<NonNullPFN_vkEnumeratePhysicalDeviceGroups>;
pub type PFN_vkEnumeratePhysicalDeviceGroupsKHR = Option<NonNullPFN_vkEnumeratePhysicalDeviceGroupsKHR>;
pub type PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = Option<NonNullPFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM>;
pub type PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = Option<NonNullPFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR>;
pub type PFN_vkEnumeratePhysicalDevices = Option<NonNullPFN_vkEnumeratePhysicalDevices>;
pub type PFN_vkFlushMappedMemoryRanges = Option<NonNullPFN_vkFlushMappedMemoryRanges>;
pub type PFN_vkFreeCommandBuffers = Option<NonNullPFN_vkFreeCommandBuffers>;
pub type PFN_vkFreeDescriptorSets = Option<NonNullPFN_vkFreeDescriptorSets>;
pub type PFN_vkFreeFunction = Option<NonNullPFN_vkFreeFunction>;
pub type PFN_vkFreeMemory = Option<NonNullPFN_vkFreeMemory>;
pub type PFN_vkGetAccelerationStructureBuildSizesKHR = Option<NonNullPFN_vkGetAccelerationStructureBuildSizesKHR>;
pub type PFN_vkGetAccelerationStructureDeviceAddressKHR = Option<NonNullPFN_vkGetAccelerationStructureDeviceAddressKHR>;
pub type PFN_vkGetAccelerationStructureHandleNV = Option<NonNullPFN_vkGetAccelerationStructureHandleNV>;
pub type PFN_vkGetAccelerationStructureMemoryRequirementsNV = Option<NonNullPFN_vkGetAccelerationStructureMemoryRequirementsNV>;
pub type PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = Option<NonNullPFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT>;
pub type PFN_vkGetBufferDeviceAddress = Option<NonNullPFN_vkGetBufferDeviceAddress>;
pub type PFN_vkGetBufferDeviceAddressEXT = Option<NonNullPFN_vkGetBufferDeviceAddressEXT>;
pub type PFN_vkGetBufferDeviceAddressKHR = Option<NonNullPFN_vkGetBufferDeviceAddressKHR>;
pub type PFN_vkGetBufferMemoryRequirements = Option<NonNullPFN_vkGetBufferMemoryRequirements>;
pub type PFN_vkGetBufferMemoryRequirements2 = Option<NonNullPFN_vkGetBufferMemoryRequirements2>;
pub type PFN_vkGetBufferMemoryRequirements2KHR = Option<NonNullPFN_vkGetBufferMemoryRequirements2KHR>;
pub type PFN_vkGetBufferOpaqueCaptureAddress = Option<NonNullPFN_vkGetBufferOpaqueCaptureAddress>;
pub type PFN_vkGetBufferOpaqueCaptureAddressKHR = Option<NonNullPFN_vkGetBufferOpaqueCaptureAddressKHR>;
pub type PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT = Option<NonNullPFN_vkGetBufferOpaqueCaptureDescriptorDataEXT>;
pub type PFN_vkGetCalibratedTimestampsEXT = Option<NonNullPFN_vkGetCalibratedTimestampsEXT>;
pub type PFN_vkGetCalibratedTimestampsKHR = Option<NonNullPFN_vkGetCalibratedTimestampsKHR>;
pub type PFN_vkGetClusterAccelerationStructureBuildSizesNV = Option<NonNullPFN_vkGetClusterAccelerationStructureBuildSizesNV>;
pub type PFN_vkGetDataGraphPipelineAvailablePropertiesARM = Option<NonNullPFN_vkGetDataGraphPipelineAvailablePropertiesARM>;
pub type PFN_vkGetDataGraphPipelinePropertiesARM = Option<NonNullPFN_vkGetDataGraphPipelinePropertiesARM>;
pub type PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM = Option<NonNullPFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM>;
pub type PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM = Option<NonNullPFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM>;
pub type PFN_vkGetDeferredOperationMaxConcurrencyKHR = Option<NonNullPFN_vkGetDeferredOperationMaxConcurrencyKHR>;
pub type PFN_vkGetDeferredOperationResultKHR = Option<NonNullPFN_vkGetDeferredOperationResultKHR>;
pub type PFN_vkGetDescriptorEXT = Option<NonNullPFN_vkGetDescriptorEXT>;
pub type PFN_vkGetDescriptorSetHostMappingVALVE = Option<NonNullPFN_vkGetDescriptorSetHostMappingVALVE>;
pub type PFN_vkGetDescriptorSetLayoutBindingOffsetEXT = Option<NonNullPFN_vkGetDescriptorSetLayoutBindingOffsetEXT>;
pub type PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE = Option<NonNullPFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE>;
pub type PFN_vkGetDescriptorSetLayoutSizeEXT = Option<NonNullPFN_vkGetDescriptorSetLayoutSizeEXT>;
pub type PFN_vkGetDescriptorSetLayoutSupport = Option<NonNullPFN_vkGetDescriptorSetLayoutSupport>;
pub type PFN_vkGetDescriptorSetLayoutSupportKHR = Option<NonNullPFN_vkGetDescriptorSetLayoutSupportKHR>;
pub type PFN_vkGetDeviceAccelerationStructureCompatibilityKHR = Option<NonNullPFN_vkGetDeviceAccelerationStructureCompatibilityKHR>;
pub type PFN_vkGetDeviceBufferMemoryRequirements = Option<NonNullPFN_vkGetDeviceBufferMemoryRequirements>;
pub type PFN_vkGetDeviceBufferMemoryRequirementsKHR = Option<NonNullPFN_vkGetDeviceBufferMemoryRequirementsKHR>;
pub type PFN_vkGetDeviceFaultInfoEXT = Option<NonNullPFN_vkGetDeviceFaultInfoEXT>;
pub type PFN_vkGetDeviceGroupPeerMemoryFeatures = Option<NonNullPFN_vkGetDeviceGroupPeerMemoryFeatures>;
pub type PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR = Option<NonNullPFN_vkGetDeviceGroupPeerMemoryFeaturesKHR>;
pub type PFN_vkGetDeviceGroupPresentCapabilitiesKHR = Option<NonNullPFN_vkGetDeviceGroupPresentCapabilitiesKHR>;
pub type PFN_vkGetDeviceGroupSurfacePresentModesKHR = Option<NonNullPFN_vkGetDeviceGroupSurfacePresentModesKHR>;
pub type PFN_vkGetDeviceImageMemoryRequirements = Option<NonNullPFN_vkGetDeviceImageMemoryRequirements>;
pub type PFN_vkGetDeviceImageMemoryRequirementsKHR = Option<NonNullPFN_vkGetDeviceImageMemoryRequirementsKHR>;
pub type PFN_vkGetDeviceImageSparseMemoryRequirements = Option<NonNullPFN_vkGetDeviceImageSparseMemoryRequirements>;
pub type PFN_vkGetDeviceImageSparseMemoryRequirementsKHR = Option<NonNullPFN_vkGetDeviceImageSparseMemoryRequirementsKHR>;
pub type PFN_vkGetDeviceImageSubresourceLayout = Option<NonNullPFN_vkGetDeviceImageSubresourceLayout>;
pub type PFN_vkGetDeviceImageSubresourceLayoutKHR = Option<NonNullPFN_vkGetDeviceImageSubresourceLayoutKHR>;
pub type PFN_vkGetDeviceMemoryCommitment = Option<NonNullPFN_vkGetDeviceMemoryCommitment>;
pub type PFN_vkGetDeviceMemoryOpaqueCaptureAddress = Option<NonNullPFN_vkGetDeviceMemoryOpaqueCaptureAddress>;
pub type PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR = Option<NonNullPFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR>;
pub type PFN_vkGetDeviceMicromapCompatibilityEXT = Option<NonNullPFN_vkGetDeviceMicromapCompatibilityEXT>;
pub type PFN_vkGetDeviceProcAddr = Option<NonNullPFN_vkGetDeviceProcAddr>;
pub type PFN_vkGetDeviceQueue = Option<NonNullPFN_vkGetDeviceQueue>;
pub type PFN_vkGetDeviceQueue2 = Option<NonNullPFN_vkGetDeviceQueue2>;
pub type PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = Option<NonNullPFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI>;
pub type PFN_vkGetDeviceTensorMemoryRequirementsARM = Option<NonNullPFN_vkGetDeviceTensorMemoryRequirementsARM>;
pub type PFN_vkGetDisplayModeProperties2KHR = Option<NonNullPFN_vkGetDisplayModeProperties2KHR>;
pub type PFN_vkGetDisplayModePropertiesKHR = Option<NonNullPFN_vkGetDisplayModePropertiesKHR>;
pub type PFN_vkGetDisplayPlaneCapabilities2KHR = Option<NonNullPFN_vkGetDisplayPlaneCapabilities2KHR>;
pub type PFN_vkGetDisplayPlaneCapabilitiesKHR = Option<NonNullPFN_vkGetDisplayPlaneCapabilitiesKHR>;
pub type PFN_vkGetDisplayPlaneSupportedDisplaysKHR = Option<NonNullPFN_vkGetDisplayPlaneSupportedDisplaysKHR>;
pub type PFN_vkGetDrmDisplayEXT = Option<NonNullPFN_vkGetDrmDisplayEXT>;
pub type PFN_vkGetDynamicRenderingTilePropertiesQCOM = Option<NonNullPFN_vkGetDynamicRenderingTilePropertiesQCOM>;
pub type PFN_vkGetEncodedVideoSessionParametersKHR = Option<NonNullPFN_vkGetEncodedVideoSessionParametersKHR>;
pub type PFN_vkGetEventStatus = Option<NonNullPFN_vkGetEventStatus>;
pub type PFN_vkGetExternalComputeQueueDataNV = Option<NonNullPFN_vkGetExternalComputeQueueDataNV>;
pub type PFN_vkGetFenceFdKHR = Option<NonNullPFN_vkGetFenceFdKHR>;
pub type PFN_vkGetFenceStatus = Option<NonNullPFN_vkGetFenceStatus>;
pub type PFN_vkGetFramebufferTilePropertiesQCOM = Option<NonNullPFN_vkGetFramebufferTilePropertiesQCOM>;
pub type PFN_vkGetGeneratedCommandsMemoryRequirementsEXT = Option<NonNullPFN_vkGetGeneratedCommandsMemoryRequirementsEXT>;
pub type PFN_vkGetGeneratedCommandsMemoryRequirementsNV = Option<NonNullPFN_vkGetGeneratedCommandsMemoryRequirementsNV>;
pub type PFN_vkGetImageDrmFormatModifierPropertiesEXT = Option<NonNullPFN_vkGetImageDrmFormatModifierPropertiesEXT>;
pub type PFN_vkGetImageMemoryRequirements = Option<NonNullPFN_vkGetImageMemoryRequirements>;
pub type PFN_vkGetImageMemoryRequirements2 = Option<NonNullPFN_vkGetImageMemoryRequirements2>;
pub type PFN_vkGetImageMemoryRequirements2KHR = Option<NonNullPFN_vkGetImageMemoryRequirements2KHR>;
pub type PFN_vkGetImageOpaqueCaptureDescriptorDataEXT = Option<NonNullPFN_vkGetImageOpaqueCaptureDescriptorDataEXT>;
pub type PFN_vkGetImageSparseMemoryRequirements = Option<NonNullPFN_vkGetImageSparseMemoryRequirements>;
pub type PFN_vkGetImageSparseMemoryRequirements2 = Option<NonNullPFN_vkGetImageSparseMemoryRequirements2>;
pub type PFN_vkGetImageSparseMemoryRequirements2KHR = Option<NonNullPFN_vkGetImageSparseMemoryRequirements2KHR>;
pub type PFN_vkGetImageSubresourceLayout = Option<NonNullPFN_vkGetImageSubresourceLayout>;
pub type PFN_vkGetImageSubresourceLayout2 = Option<NonNullPFN_vkGetImageSubresourceLayout2>;
pub type PFN_vkGetImageSubresourceLayout2EXT = Option<NonNullPFN_vkGetImageSubresourceLayout2EXT>;
pub type PFN_vkGetImageSubresourceLayout2KHR = Option<NonNullPFN_vkGetImageSubresourceLayout2KHR>;
pub type PFN_vkGetImageViewAddressNVX = Option<NonNullPFN_vkGetImageViewAddressNVX>;
pub type PFN_vkGetImageViewHandle64NVX = Option<NonNullPFN_vkGetImageViewHandle64NVX>;
pub type PFN_vkGetImageViewHandleNVX = Option<NonNullPFN_vkGetImageViewHandleNVX>;
pub type PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT = Option<NonNullPFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT>;
pub type PFN_vkGetInstanceProcAddr = Option<NonNullPFN_vkGetInstanceProcAddr>;
pub type PFN_vkGetInstanceProcAddrLUNARG = Option<NonNullPFN_vkGetInstanceProcAddrLUNARG>;
pub type PFN_vkGetLatencyTimingsNV = Option<NonNullPFN_vkGetLatencyTimingsNV>;
pub type PFN_vkGetMemoryFdKHR = Option<NonNullPFN_vkGetMemoryFdKHR>;
pub type PFN_vkGetMemoryFdPropertiesKHR = Option<NonNullPFN_vkGetMemoryFdPropertiesKHR>;
pub type PFN_vkGetMemoryHostPointerPropertiesEXT = Option<NonNullPFN_vkGetMemoryHostPointerPropertiesEXT>;
pub type PFN_vkGetMemoryRemoteAddressNV = Option<NonNullPFN_vkGetMemoryRemoteAddressNV>;
pub type PFN_vkGetMicromapBuildSizesEXT = Option<NonNullPFN_vkGetMicromapBuildSizesEXT>;
pub type PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV = Option<NonNullPFN_vkGetPartitionedAccelerationStructuresBuildSizesNV>;
pub type PFN_vkGetPastPresentationTimingEXT = Option<NonNullPFN_vkGetPastPresentationTimingEXT>;
pub type PFN_vkGetPastPresentationTimingGOOGLE = Option<NonNullPFN_vkGetPastPresentationTimingGOOGLE>;
pub type PFN_vkGetPerformanceParameterINTEL = Option<NonNullPFN_vkGetPerformanceParameterINTEL>;
pub type PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = Option<NonNullPFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT>;
pub type PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = Option<NonNullPFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR>;
pub type PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = Option<NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV>;
pub type PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR>;
pub type PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = Option<NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV>;
pub type PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV = Option<NonNullPFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV>;
pub type PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR>;
pub type PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR>;
pub type PFN_vkGetPhysicalDeviceDisplayProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceDisplayProperties2KHR>;
pub type PFN_vkGetPhysicalDeviceDisplayPropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceDisplayPropertiesKHR>;
pub type PFN_vkGetPhysicalDeviceExternalBufferProperties = Option<NonNullPFN_vkGetPhysicalDeviceExternalBufferProperties>;
pub type PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR>;
pub type PFN_vkGetPhysicalDeviceExternalFenceProperties = Option<NonNullPFN_vkGetPhysicalDeviceExternalFenceProperties>;
pub type PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceExternalFencePropertiesKHR>;
pub type PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = Option<NonNullPFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV>;
pub type PFN_vkGetPhysicalDeviceExternalSemaphoreProperties = Option<NonNullPFN_vkGetPhysicalDeviceExternalSemaphoreProperties>;
pub type PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR>;
pub type PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM = Option<NonNullPFN_vkGetPhysicalDeviceExternalTensorPropertiesARM>;
pub type PFN_vkGetPhysicalDeviceFeatures = Option<NonNullPFN_vkGetPhysicalDeviceFeatures>;
pub type PFN_vkGetPhysicalDeviceFeatures2 = Option<NonNullPFN_vkGetPhysicalDeviceFeatures2>;
pub type PFN_vkGetPhysicalDeviceFeatures2KHR = Option<NonNullPFN_vkGetPhysicalDeviceFeatures2KHR>;
pub type PFN_vkGetPhysicalDeviceFormatProperties = Option<NonNullPFN_vkGetPhysicalDeviceFormatProperties>;
pub type PFN_vkGetPhysicalDeviceFormatProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceFormatProperties2>;
pub type PFN_vkGetPhysicalDeviceFormatProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceFormatProperties2KHR>;
pub type PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = Option<NonNullPFN_vkGetPhysicalDeviceFragmentShadingRatesKHR>;
pub type PFN_vkGetPhysicalDeviceImageFormatProperties = Option<NonNullPFN_vkGetPhysicalDeviceImageFormatProperties>;
pub type PFN_vkGetPhysicalDeviceImageFormatProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceImageFormatProperties2>;
pub type PFN_vkGetPhysicalDeviceImageFormatProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceImageFormatProperties2KHR>;
pub type PFN_vkGetPhysicalDeviceMemoryProperties = Option<NonNullPFN_vkGetPhysicalDeviceMemoryProperties>;
pub type PFN_vkGetPhysicalDeviceMemoryProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceMemoryProperties2>;
pub type PFN_vkGetPhysicalDeviceMemoryProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceMemoryProperties2KHR>;
pub type PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT = Option<NonNullPFN_vkGetPhysicalDeviceMultisamplePropertiesEXT>;
pub type PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = Option<NonNullPFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV>;
pub type PFN_vkGetPhysicalDevicePresentRectanglesKHR = Option<NonNullPFN_vkGetPhysicalDevicePresentRectanglesKHR>;
pub type PFN_vkGetPhysicalDeviceProperties = Option<NonNullPFN_vkGetPhysicalDeviceProperties>;
pub type PFN_vkGetPhysicalDeviceProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceProperties2>;
pub type PFN_vkGetPhysicalDeviceProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceProperties2KHR>;
pub type PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM>;
pub type PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM>;
pub type PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR>;
pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties>;
pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties2>;
pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR>;
pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties = Option<NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties>;
pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties2>;
pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR>;
pub type PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = Option<NonNullPFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV>;
pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT>;
pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR>;
pub type PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>;
pub type PFN_vkGetPhysicalDeviceSurfaceFormats2KHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceFormats2KHR>;
pub type PFN_vkGetPhysicalDeviceSurfaceFormatsKHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceFormatsKHR>;
pub type PFN_vkGetPhysicalDeviceSurfacePresentModesKHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfacePresentModesKHR>;
pub type PFN_vkGetPhysicalDeviceSurfaceSupportKHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceSupportKHR>;
pub type PFN_vkGetPhysicalDeviceToolProperties = Option<NonNullPFN_vkGetPhysicalDeviceToolProperties>;
pub type PFN_vkGetPhysicalDeviceToolPropertiesEXT = Option<NonNullPFN_vkGetPhysicalDeviceToolPropertiesEXT>;
pub type PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceVideoCapabilitiesKHR>;
pub type PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR>;
pub type PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR>;
pub type PFN_vkGetPipelineBinaryDataKHR = Option<NonNullPFN_vkGetPipelineBinaryDataKHR>;
pub type PFN_vkGetPipelineCacheData = Option<NonNullPFN_vkGetPipelineCacheData>;
pub type PFN_vkGetPipelineExecutableInternalRepresentationsKHR = Option<NonNullPFN_vkGetPipelineExecutableInternalRepresentationsKHR>;
pub type PFN_vkGetPipelineExecutablePropertiesKHR = Option<NonNullPFN_vkGetPipelineExecutablePropertiesKHR>;
pub type PFN_vkGetPipelineExecutableStatisticsKHR = Option<NonNullPFN_vkGetPipelineExecutableStatisticsKHR>;
pub type PFN_vkGetPipelineIndirectDeviceAddressNV = Option<NonNullPFN_vkGetPipelineIndirectDeviceAddressNV>;
pub type PFN_vkGetPipelineIndirectMemoryRequirementsNV = Option<NonNullPFN_vkGetPipelineIndirectMemoryRequirementsNV>;
pub type PFN_vkGetPipelineKeyKHR = Option<NonNullPFN_vkGetPipelineKeyKHR>;
pub type PFN_vkGetPipelinePropertiesEXT = Option<NonNullPFN_vkGetPipelinePropertiesEXT>;
pub type PFN_vkGetPrivateData = Option<NonNullPFN_vkGetPrivateData>;
pub type PFN_vkGetPrivateDataEXT = Option<NonNullPFN_vkGetPrivateDataEXT>;
pub type PFN_vkGetQueryPoolResults = Option<NonNullPFN_vkGetQueryPoolResults>;
pub type PFN_vkGetQueueCheckpointData2NV = Option<NonNullPFN_vkGetQueueCheckpointData2NV>;
pub type PFN_vkGetQueueCheckpointDataNV = Option<NonNullPFN_vkGetQueueCheckpointDataNV>;
pub type PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = Option<NonNullPFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR>;
pub type PFN_vkGetRayTracingShaderGroupHandlesKHR = Option<NonNullPFN_vkGetRayTracingShaderGroupHandlesKHR>;
pub type PFN_vkGetRayTracingShaderGroupHandlesNV = Option<NonNullPFN_vkGetRayTracingShaderGroupHandlesNV>;
pub type PFN_vkGetRayTracingShaderGroupStackSizeKHR = Option<NonNullPFN_vkGetRayTracingShaderGroupStackSizeKHR>;
pub type PFN_vkGetRefreshCycleDurationGOOGLE = Option<NonNullPFN_vkGetRefreshCycleDurationGOOGLE>;
pub type PFN_vkGetRenderAreaGranularity = Option<NonNullPFN_vkGetRenderAreaGranularity>;
pub type PFN_vkGetRenderingAreaGranularity = Option<NonNullPFN_vkGetRenderingAreaGranularity>;
pub type PFN_vkGetRenderingAreaGranularityKHR = Option<NonNullPFN_vkGetRenderingAreaGranularityKHR>;
pub type PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT = Option<NonNullPFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT>;
pub type PFN_vkGetSemaphoreCounterValue = Option<NonNullPFN_vkGetSemaphoreCounterValue>;
pub type PFN_vkGetSemaphoreCounterValueKHR = Option<NonNullPFN_vkGetSemaphoreCounterValueKHR>;
pub type PFN_vkGetSemaphoreFdKHR = Option<NonNullPFN_vkGetSemaphoreFdKHR>;
pub type PFN_vkGetShaderBinaryDataEXT = Option<NonNullPFN_vkGetShaderBinaryDataEXT>;
pub type PFN_vkGetShaderInfoAMD = Option<NonNullPFN_vkGetShaderInfoAMD>;
pub type PFN_vkGetShaderModuleCreateInfoIdentifierEXT = Option<NonNullPFN_vkGetShaderModuleCreateInfoIdentifierEXT>;
pub type PFN_vkGetShaderModuleIdentifierEXT = Option<NonNullPFN_vkGetShaderModuleIdentifierEXT>;
pub type PFN_vkGetSwapchainCounterEXT = Option<NonNullPFN_vkGetSwapchainCounterEXT>;
pub type PFN_vkGetSwapchainImagesKHR = Option<NonNullPFN_vkGetSwapchainImagesKHR>;
pub type PFN_vkGetSwapchainStatusKHR = Option<NonNullPFN_vkGetSwapchainStatusKHR>;
pub type PFN_vkGetSwapchainTimeDomainPropertiesEXT = Option<NonNullPFN_vkGetSwapchainTimeDomainPropertiesEXT>;
pub type PFN_vkGetSwapchainTimingPropertiesEXT = Option<NonNullPFN_vkGetSwapchainTimingPropertiesEXT>;
pub type PFN_vkGetTensorMemoryRequirementsARM = Option<NonNullPFN_vkGetTensorMemoryRequirementsARM>;
pub type PFN_vkGetTensorOpaqueCaptureDescriptorDataARM = Option<NonNullPFN_vkGetTensorOpaqueCaptureDescriptorDataARM>;
pub type PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM = Option<NonNullPFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM>;
pub type PFN_vkGetValidationCacheDataEXT = Option<NonNullPFN_vkGetValidationCacheDataEXT>;
pub type PFN_vkGetVideoSessionMemoryRequirementsKHR = Option<NonNullPFN_vkGetVideoSessionMemoryRequirementsKHR>;
pub type PFN_vkImportFenceFdKHR = Option<NonNullPFN_vkImportFenceFdKHR>;
pub type PFN_vkImportSemaphoreFdKHR = Option<NonNullPFN_vkImportSemaphoreFdKHR>;
pub type PFN_vkInitializePerformanceApiINTEL = Option<NonNullPFN_vkInitializePerformanceApiINTEL>;
pub type PFN_vkInternalAllocationNotification = Option<NonNullPFN_vkInternalAllocationNotification>;
pub type PFN_vkInternalFreeNotification = Option<NonNullPFN_vkInternalFreeNotification>;
pub type PFN_vkInvalidateMappedMemoryRanges = Option<NonNullPFN_vkInvalidateMappedMemoryRanges>;
pub type PFN_vkLatencySleepNV = Option<NonNullPFN_vkLatencySleepNV>;
pub type PFN_vkMapMemory = Option<NonNullPFN_vkMapMemory>;
pub type PFN_vkMapMemory2 = Option<NonNullPFN_vkMapMemory2>;
pub type PFN_vkMapMemory2KHR = Option<NonNullPFN_vkMapMemory2KHR>;
pub type PFN_vkMergePipelineCaches = Option<NonNullPFN_vkMergePipelineCaches>;
pub type PFN_vkMergeValidationCachesEXT = Option<NonNullPFN_vkMergeValidationCachesEXT>;
pub type PFN_vkQueueBeginDebugUtilsLabelEXT = Option<NonNullPFN_vkQueueBeginDebugUtilsLabelEXT>;
pub type PFN_vkQueueBindSparse = Option<NonNullPFN_vkQueueBindSparse>;
pub type PFN_vkQueueEndDebugUtilsLabelEXT = Option<NonNullPFN_vkQueueEndDebugUtilsLabelEXT>;
pub type PFN_vkQueueInsertDebugUtilsLabelEXT = Option<NonNullPFN_vkQueueInsertDebugUtilsLabelEXT>;
pub type PFN_vkQueueNotifyOutOfBandNV = Option<NonNullPFN_vkQueueNotifyOutOfBandNV>;
pub type PFN_vkQueuePresentKHR = Option<NonNullPFN_vkQueuePresentKHR>;
pub type PFN_vkQueueSetPerformanceConfigurationINTEL = Option<NonNullPFN_vkQueueSetPerformanceConfigurationINTEL>;
pub type PFN_vkQueueSubmit = Option<NonNullPFN_vkQueueSubmit>;
pub type PFN_vkQueueSubmit2 = Option<NonNullPFN_vkQueueSubmit2>;
pub type PFN_vkQueueSubmit2KHR = Option<NonNullPFN_vkQueueSubmit2KHR>;
pub type PFN_vkQueueWaitIdle = Option<NonNullPFN_vkQueueWaitIdle>;
pub type PFN_vkReallocationFunction = Option<NonNullPFN_vkReallocationFunction>;
pub type PFN_vkRegisterDeviceEventEXT = Option<NonNullPFN_vkRegisterDeviceEventEXT>;
pub type PFN_vkRegisterDisplayEventEXT = Option<NonNullPFN_vkRegisterDisplayEventEXT>;
pub type PFN_vkReleaseCapturedPipelineDataKHR = Option<NonNullPFN_vkReleaseCapturedPipelineDataKHR>;
pub type PFN_vkReleaseDisplayEXT = Option<NonNullPFN_vkReleaseDisplayEXT>;
pub type PFN_vkReleasePerformanceConfigurationINTEL = Option<NonNullPFN_vkReleasePerformanceConfigurationINTEL>;
pub type PFN_vkReleaseProfilingLockKHR = Option<NonNullPFN_vkReleaseProfilingLockKHR>;
pub type PFN_vkReleaseSwapchainImagesEXT = Option<NonNullPFN_vkReleaseSwapchainImagesEXT>;
pub type PFN_vkReleaseSwapchainImagesKHR = Option<NonNullPFN_vkReleaseSwapchainImagesKHR>;
pub type PFN_vkResetCommandBuffer = Option<NonNullPFN_vkResetCommandBuffer>;
pub type PFN_vkResetCommandPool = Option<NonNullPFN_vkResetCommandPool>;
pub type PFN_vkResetDescriptorPool = Option<NonNullPFN_vkResetDescriptorPool>;
pub type PFN_vkResetEvent = Option<NonNullPFN_vkResetEvent>;
pub type PFN_vkResetFences = Option<NonNullPFN_vkResetFences>;
pub type PFN_vkResetQueryPool = Option<NonNullPFN_vkResetQueryPool>;
pub type PFN_vkResetQueryPoolEXT = Option<NonNullPFN_vkResetQueryPoolEXT>;
pub type PFN_vkSetDebugUtilsObjectNameEXT = Option<NonNullPFN_vkSetDebugUtilsObjectNameEXT>;
pub type PFN_vkSetDebugUtilsObjectTagEXT = Option<NonNullPFN_vkSetDebugUtilsObjectTagEXT>;
pub type PFN_vkSetDeviceMemoryPriorityEXT = Option<NonNullPFN_vkSetDeviceMemoryPriorityEXT>;
pub type PFN_vkSetEvent = Option<NonNullPFN_vkSetEvent>;
pub type PFN_vkSetHdrMetadataEXT = Option<NonNullPFN_vkSetHdrMetadataEXT>;
pub type PFN_vkSetLatencyMarkerNV = Option<NonNullPFN_vkSetLatencyMarkerNV>;
pub type PFN_vkSetLatencySleepModeNV = Option<NonNullPFN_vkSetLatencySleepModeNV>;
pub type PFN_vkSetLocalDimmingAMD = Option<NonNullPFN_vkSetLocalDimmingAMD>;
pub type PFN_vkSetPrivateData = Option<NonNullPFN_vkSetPrivateData>;
pub type PFN_vkSetPrivateDataEXT = Option<NonNullPFN_vkSetPrivateDataEXT>;
pub type PFN_vkSetSwapchainPresentTimingQueueSizeEXT = Option<NonNullPFN_vkSetSwapchainPresentTimingQueueSizeEXT>;
pub type PFN_vkSignalSemaphore = Option<NonNullPFN_vkSignalSemaphore>;
pub type PFN_vkSignalSemaphoreKHR = Option<NonNullPFN_vkSignalSemaphoreKHR>;
pub type PFN_vkSubmitDebugUtilsMessageEXT = Option<NonNullPFN_vkSubmitDebugUtilsMessageEXT>;
pub type PFN_vkTransitionImageLayout = Option<NonNullPFN_vkTransitionImageLayout>;
pub type PFN_vkTransitionImageLayoutEXT = Option<NonNullPFN_vkTransitionImageLayoutEXT>;
pub type PFN_vkTrimCommandPool = Option<NonNullPFN_vkTrimCommandPool>;
pub type PFN_vkTrimCommandPoolKHR = Option<NonNullPFN_vkTrimCommandPoolKHR>;
pub type PFN_vkUninitializePerformanceApiINTEL = Option<NonNullPFN_vkUninitializePerformanceApiINTEL>;
pub type PFN_vkUnmapMemory = Option<NonNullPFN_vkUnmapMemory>;
pub type PFN_vkUnmapMemory2 = Option<NonNullPFN_vkUnmapMemory2>;
pub type PFN_vkUnmapMemory2KHR = Option<NonNullPFN_vkUnmapMemory2KHR>;
pub type PFN_vkUpdateDescriptorSetWithTemplate = Option<NonNullPFN_vkUpdateDescriptorSetWithTemplate>;
pub type PFN_vkUpdateDescriptorSetWithTemplateKHR = Option<NonNullPFN_vkUpdateDescriptorSetWithTemplateKHR>;
pub type PFN_vkUpdateDescriptorSets = Option<NonNullPFN_vkUpdateDescriptorSets>;
pub type PFN_vkUpdateIndirectExecutionSetPipelineEXT = Option<NonNullPFN_vkUpdateIndirectExecutionSetPipelineEXT>;
pub type PFN_vkUpdateIndirectExecutionSetShaderEXT = Option<NonNullPFN_vkUpdateIndirectExecutionSetShaderEXT>;
pub type PFN_vkUpdateVideoSessionParametersKHR = Option<NonNullPFN_vkUpdateVideoSessionParametersKHR>;
pub type PFN_vkVoidFunction = Option<NonNullPFN_vkVoidFunction>;
pub type PFN_vkWaitForFences = Option<NonNullPFN_vkWaitForFences>;
pub type PFN_vkWaitForPresent2KHR = Option<NonNullPFN_vkWaitForPresent2KHR>;
pub type PFN_vkWaitForPresentKHR = Option<NonNullPFN_vkWaitForPresentKHR>;
pub type PFN_vkWaitSemaphores = Option<NonNullPFN_vkWaitSemaphores>;
pub type PFN_vkWaitSemaphoresKHR = Option<NonNullPFN_vkWaitSemaphoresKHR>;
pub type PFN_vkWriteAccelerationStructuresPropertiesKHR = Option<NonNullPFN_vkWriteAccelerationStructuresPropertiesKHR>;
pub type PFN_vkWriteMicromapsPropertiesEXT = Option<NonNullPFN_vkWriteMicromapsPropertiesEXT>;
pub type VkAabbPositionsNV = VkAabbPositionsKHR;
pub type VkAccelerationStructureBuildTypeKHR = i32;
pub type VkAccelerationStructureCompatibilityKHR = i32;
pub type VkAccelerationStructureCreateFlagBitsKHR = VkFlags;
pub type VkAccelerationStructureCreateFlagsKHR = VkFlags;
pub type VkAccelerationStructureInstanceNV = VkAccelerationStructureInstanceKHR;
pub type VkAccelerationStructureKHR = *mut VkAccelerationStructureKHR_T;
pub type VkAccelerationStructureMemoryRequirementsTypeNV = i32;
pub type VkAccelerationStructureMotionInfoFlagsNV = VkFlags;
pub type VkAccelerationStructureMotionInstanceFlagsNV = VkFlags;
pub type VkAccelerationStructureMotionInstanceTypeNV = i32;
pub type VkAccelerationStructureNV = *mut VkAccelerationStructureNV_T;
pub type VkAccelerationStructureTypeKHR = i32;
pub type VkAccelerationStructureTypeNV = VkAccelerationStructureTypeKHR;
pub type VkAccessFlagBits = VkFlags;
pub type VkAccessFlagBits2 = VkFlags64;
pub type VkAccessFlagBits2KHR = VkAccessFlagBits2;
pub type VkAccessFlagBits3KHR = VkFlags64;
pub type VkAccessFlags = VkFlags;
pub type VkAccessFlags2 = VkFlags64;
pub type VkAccessFlags2KHR = VkAccessFlags2;
pub type VkAccessFlags3KHR = VkFlags64;
pub type VkAcquireProfilingLockFlagBitsKHR = VkFlags;
pub type VkAcquireProfilingLockFlagsKHR = VkFlags;
pub type VkAddressCopyFlagBitsKHR = VkFlags;
pub type VkAddressCopyFlagsKHR = VkFlags;
pub type VkAntiLagModeAMD = i32;
pub type VkAntiLagStageAMD = i32;
pub type VkAttachmentDescription2KHR = VkAttachmentDescription2;
pub type VkAttachmentDescriptionFlagBits = VkFlags;
pub type VkAttachmentDescriptionFlags = VkFlags;
pub type VkAttachmentDescriptionStencilLayoutKHR = VkAttachmentDescriptionStencilLayout;
pub type VkAttachmentLoadOp = i32;
pub type VkAttachmentReference2KHR = VkAttachmentReference2;
pub type VkAttachmentReferenceStencilLayoutKHR = VkAttachmentReferenceStencilLayout;
pub type VkAttachmentSampleCountInfoNV = VkAttachmentSampleCountInfoAMD;
pub type VkAttachmentStoreOp = i32;
pub type VkBindBufferMemoryDeviceGroupInfoKHR = VkBindBufferMemoryDeviceGroupInfo;
pub type VkBindBufferMemoryInfoKHR = VkBindBufferMemoryInfo;
pub type VkBindDescriptorSetsInfoKHR = VkBindDescriptorSetsInfo;
pub type VkBindImageMemoryDeviceGroupInfoKHR = VkBindImageMemoryDeviceGroupInfo;
pub type VkBindImageMemoryInfoKHR = VkBindImageMemoryInfo;
pub type VkBindImagePlaneMemoryInfoKHR = VkBindImagePlaneMemoryInfo;
pub type VkBindMemoryStatusKHR = VkBindMemoryStatus;
pub type VkBlendFactor = i32;
pub type VkBlendOp = i32;
pub type VkBlendOverlapEXT = i32;
pub type VkBlitImageInfo2KHR = VkBlitImageInfo2;
pub type VkBlockMatchWindowCompareModeQCOM = i32;
pub type VkBool32 = u32;
pub type VkBorderColor = i32;
pub type VkBuffer = *mut VkBuffer_T;
pub type VkBufferCopy2KHR = VkBufferCopy2;
pub type VkBufferCreateFlagBits = VkFlags;
pub type VkBufferCreateFlags = VkFlags;
pub type VkBufferDeviceAddressInfoEXT = VkBufferDeviceAddressInfo;
pub type VkBufferDeviceAddressInfoKHR = VkBufferDeviceAddressInfo;
pub type VkBufferImageCopy2KHR = VkBufferImageCopy2;
pub type VkBufferMemoryBarrier2KHR = VkBufferMemoryBarrier2;
pub type VkBufferMemoryRequirementsInfo2KHR = VkBufferMemoryRequirementsInfo2;
pub type VkBufferOpaqueCaptureAddressCreateInfoKHR = VkBufferOpaqueCaptureAddressCreateInfo;
pub type VkBufferUsageFlagBits = VkFlags;
pub type VkBufferUsageFlagBits2 = VkFlags64;
pub type VkBufferUsageFlagBits2KHR = VkBufferUsageFlagBits2;
pub type VkBufferUsageFlags = VkFlags;
pub type VkBufferUsageFlags2 = VkFlags64;
pub type VkBufferUsageFlags2CreateInfoKHR = VkBufferUsageFlags2CreateInfo;
pub type VkBufferUsageFlags2KHR = VkBufferUsageFlags2;
pub type VkBufferView = *mut VkBufferView_T;
pub type VkBufferViewCreateFlags = VkFlags;
pub type VkBuildAccelerationStructureFlagBitsKHR = VkFlags;
pub type VkBuildAccelerationStructureFlagBitsNV = VkBuildAccelerationStructureFlagBitsKHR;
pub type VkBuildAccelerationStructureFlagsKHR = VkFlags;
pub type VkBuildAccelerationStructureFlagsNV = VkBuildAccelerationStructureFlagsKHR;
pub type VkBuildAccelerationStructureModeKHR = i32;
pub type VkBuildMicromapFlagBitsEXT = VkFlags;
pub type VkBuildMicromapFlagsEXT = VkFlags;
pub type VkBuildMicromapModeEXT = i32;
pub type VkCalibratedTimestampInfoEXT = VkCalibratedTimestampInfoKHR;
pub type VkChromaLocation = i32;
pub type VkChromaLocationKHR = VkChromaLocation;
pub type VkClusterAccelerationStructureAddressResolutionFlagBitsNV = VkFlags;
pub type VkClusterAccelerationStructureAddressResolutionFlagsNV = VkFlags;
pub type VkClusterAccelerationStructureClusterFlagBitsNV = VkFlags;
pub type VkClusterAccelerationStructureClusterFlagsNV = VkFlags;
pub type VkClusterAccelerationStructureGeometryFlagBitsNV = VkFlags;
pub type VkClusterAccelerationStructureGeometryFlagsNV = VkFlags;
pub type VkClusterAccelerationStructureIndexFormatFlagBitsNV = VkFlags;
pub type VkClusterAccelerationStructureIndexFormatFlagsNV = VkFlags;
pub type VkClusterAccelerationStructureOpModeNV = i32;
pub type VkClusterAccelerationStructureOpTypeNV = i32;
pub type VkClusterAccelerationStructureTypeNV = i32;
pub type VkCoarseSampleOrderTypeNV = i32;
pub type VkColorComponentFlagBits = VkFlags;
pub type VkColorComponentFlags = VkFlags;
pub type VkColorSpaceKHR = i32;
pub type VkCommandBuffer = *mut VkCommandBuffer_T;
pub type VkCommandBufferInheritanceRenderingInfoKHR = VkCommandBufferInheritanceRenderingInfo;
pub type VkCommandBufferLevel = i32;
pub type VkCommandBufferResetFlagBits = VkFlags;
pub type VkCommandBufferResetFlags = VkFlags;
pub type VkCommandBufferSubmitInfoKHR = VkCommandBufferSubmitInfo;
pub type VkCommandBufferUsageFlagBits = VkFlags;
pub type VkCommandBufferUsageFlags = VkFlags;
pub type VkCommandPool = *mut VkCommandPool_T;
pub type VkCommandPoolCreateFlagBits = VkFlags;
pub type VkCommandPoolCreateFlags = VkFlags;
pub type VkCommandPoolResetFlagBits = VkFlags;
pub type VkCommandPoolResetFlags = VkFlags;
pub type VkCommandPoolTrimFlags = VkFlags;
pub type VkCommandPoolTrimFlagsKHR = VkCommandPoolTrimFlags;
pub type VkCompareOp = i32;
pub type VkComponentSwizzle = i32;
pub type VkComponentTypeKHR = i32;
pub type VkComponentTypeNV = VkComponentTypeKHR;
pub type VkCompositeAlphaFlagBitsKHR = VkFlags;
pub type VkCompositeAlphaFlagsKHR = VkFlags;
pub type VkConditionalRenderingFlagBitsEXT = VkFlags;
pub type VkConditionalRenderingFlagsEXT = VkFlags;
pub type VkConformanceVersionKHR = VkConformanceVersion;
pub type VkConservativeRasterizationModeEXT = i32;
pub type VkCooperativeVectorMatrixLayoutNV = i32;
pub type VkCopyAccelerationStructureModeKHR = i32;
pub type VkCopyAccelerationStructureModeNV = VkCopyAccelerationStructureModeKHR;
pub type VkCopyBufferInfo2KHR = VkCopyBufferInfo2;
pub type VkCopyBufferToImageInfo2KHR = VkCopyBufferToImageInfo2;
pub type VkCopyImageInfo2KHR = VkCopyImageInfo2;
pub type VkCopyImageToBufferInfo2KHR = VkCopyImageToBufferInfo2;
pub type VkCopyImageToImageInfoEXT = VkCopyImageToImageInfo;
pub type VkCopyImageToMemoryInfoEXT = VkCopyImageToMemoryInfo;
pub type VkCopyMemoryIndirectCommandNV = VkCopyMemoryIndirectCommandKHR;
pub type VkCopyMemoryToImageIndirectCommandNV = VkCopyMemoryToImageIndirectCommandKHR;
pub type VkCopyMemoryToImageInfoEXT = VkCopyMemoryToImageInfo;
pub type VkCopyMicromapModeEXT = i32;
pub type VkCoverageModulationModeNV = i32;
pub type VkCoverageReductionModeNV = i32;
pub type VkCuFunctionNVX = *mut VkCuFunctionNVX_T;
pub type VkCuModuleNVX = *mut VkCuModuleNVX_T;
pub type VkCubicFilterWeightsQCOM = i32;
pub type VkCullModeFlagBits = VkFlags;
pub type VkCullModeFlags = VkFlags;
pub type VkDataGraphModelCacheTypeQCOM = i32;
pub type VkDataGraphPipelineDispatchFlagBitsARM = VkFlags64;
pub type VkDataGraphPipelineDispatchFlagsARM = VkFlags64;
pub type VkDataGraphPipelinePropertyARM = i32;
pub type VkDataGraphPipelineSessionARM = *mut VkDataGraphPipelineSessionARM_T;
pub type VkDataGraphPipelineSessionBindPointARM = i32;
pub type VkDataGraphPipelineSessionBindPointTypeARM = i32;
pub type VkDataGraphPipelineSessionCreateFlagBitsARM = VkFlags64;
pub type VkDataGraphPipelineSessionCreateFlagsARM = VkFlags64;
pub type VkDebugReportCallbackEXT = *mut VkDebugReportCallbackEXT_T;
pub type VkDebugReportFlagBitsEXT = VkFlags;
pub type VkDebugReportFlagsEXT = VkFlags;
pub type VkDebugReportObjectTypeEXT = i32;
pub type VkDebugUtilsMessageSeverityFlagBitsEXT = VkFlags;
pub type VkDebugUtilsMessageSeverityFlagsEXT = VkFlags;
pub type VkDebugUtilsMessageTypeFlagBitsEXT = VkFlags;
pub type VkDebugUtilsMessageTypeFlagsEXT = VkFlags;
pub type VkDebugUtilsMessengerCallbackDataFlagsEXT = VkFlags;
pub type VkDebugUtilsMessengerCreateFlagsEXT = VkFlags;
pub type VkDebugUtilsMessengerEXT = *mut VkDebugUtilsMessengerEXT_T;
pub type VkDefaultVertexAttributeValueKHR = i32;
pub type VkDeferredOperationKHR = *mut VkDeferredOperationKHR_T;
pub type VkDependencyFlagBits = VkFlags;
pub type VkDependencyFlags = VkFlags;
pub type VkDependencyInfoKHR = VkDependencyInfo;
pub type VkDepthBiasRepresentationEXT = i32;
pub type VkDepthClampModeEXT = i32;
pub type VkDescriptorBindingFlagBits = VkFlags;
pub type VkDescriptorBindingFlagBitsEXT = VkDescriptorBindingFlagBits;
pub type VkDescriptorBindingFlags = VkFlags;
pub type VkDescriptorBindingFlagsEXT = VkDescriptorBindingFlags;
pub type VkDescriptorPool = *mut VkDescriptorPool_T;
pub type VkDescriptorPoolCreateFlagBits = VkFlags;
pub type VkDescriptorPoolCreateFlags = VkFlags;
pub type VkDescriptorPoolInlineUniformBlockCreateInfoEXT = VkDescriptorPoolInlineUniformBlockCreateInfo;
pub type VkDescriptorPoolResetFlags = VkFlags;
pub type VkDescriptorSet = *mut VkDescriptorSet_T;
pub type VkDescriptorSetLayout = *mut VkDescriptorSetLayout_T;
pub type VkDescriptorSetLayoutBindingFlagsCreateInfoEXT = VkDescriptorSetLayoutBindingFlagsCreateInfo;
pub type VkDescriptorSetLayoutCreateFlagBits = VkFlags;
pub type VkDescriptorSetLayoutCreateFlags = VkFlags;
pub type VkDescriptorSetLayoutSupportKHR = VkDescriptorSetLayoutSupport;
pub type VkDescriptorSetVariableDescriptorCountAllocateInfoEXT = VkDescriptorSetVariableDescriptorCountAllocateInfo;
pub type VkDescriptorSetVariableDescriptorCountLayoutSupportEXT = VkDescriptorSetVariableDescriptorCountLayoutSupport;
pub type VkDescriptorType = i32;
pub type VkDescriptorUpdateTemplate = *mut VkDescriptorUpdateTemplate_T;
pub type VkDescriptorUpdateTemplateCreateFlags = VkFlags;
pub type VkDescriptorUpdateTemplateCreateFlagsKHR = VkDescriptorUpdateTemplateCreateFlags;
pub type VkDescriptorUpdateTemplateCreateInfoKHR = VkDescriptorUpdateTemplateCreateInfo;
pub type VkDescriptorUpdateTemplateEntryKHR = VkDescriptorUpdateTemplateEntry;
pub type VkDescriptorUpdateTemplateKHR = *mut VkDescriptorUpdateTemplateKHR_T;
pub type VkDescriptorUpdateTemplateKHR_T = VkDescriptorUpdateTemplate_T;
pub type VkDescriptorUpdateTemplateType = i32;
pub type VkDescriptorUpdateTemplateTypeKHR = VkDescriptorUpdateTemplateType;
pub type VkDevice = *mut VkDevice_T;
pub type VkDeviceAddress = u64;
pub type VkDeviceAddressBindingFlagBitsEXT = VkFlags;
pub type VkDeviceAddressBindingFlagsEXT = VkFlags;
pub type VkDeviceAddressBindingTypeEXT = i32;
pub type VkDeviceBufferMemoryRequirementsKHR = VkDeviceBufferMemoryRequirements;
pub type VkDeviceCreateFlags = VkFlags;
pub type VkDeviceDiagnosticsConfigFlagBitsNV = VkFlags;
pub type VkDeviceDiagnosticsConfigFlagsNV = VkFlags;
pub type VkDeviceEventTypeEXT = i32;
pub type VkDeviceFaultAddressTypeEXT = i32;
pub type VkDeviceFaultVendorBinaryHeaderVersionEXT = i32;
pub type VkDeviceGroupBindSparseInfoKHR = VkDeviceGroupBindSparseInfo;
pub type VkDeviceGroupCommandBufferBeginInfoKHR = VkDeviceGroupCommandBufferBeginInfo;
pub type VkDeviceGroupDeviceCreateInfoKHR = VkDeviceGroupDeviceCreateInfo;
pub type VkDeviceGroupPresentModeFlagBitsKHR = VkFlags;
pub type VkDeviceGroupPresentModeFlagsKHR = VkFlags;
pub type VkDeviceGroupRenderPassBeginInfoKHR = VkDeviceGroupRenderPassBeginInfo;
pub type VkDeviceGroupSubmitInfoKHR = VkDeviceGroupSubmitInfo;
pub type VkDeviceImageMemoryRequirementsKHR = VkDeviceImageMemoryRequirements;
pub type VkDeviceImageSubresourceInfoKHR = VkDeviceImageSubresourceInfo;
pub type VkDeviceMemory = *mut VkDeviceMemory_T;
pub type VkDeviceMemoryOpaqueCaptureAddressInfoKHR = VkDeviceMemoryOpaqueCaptureAddressInfo;
pub type VkDeviceMemoryReportEventTypeEXT = i32;
pub type VkDeviceMemoryReportFlagsEXT = VkFlags;
pub type VkDevicePrivateDataCreateInfoEXT = VkDevicePrivateDataCreateInfo;
pub type VkDeviceQueueCreateFlagBits = VkFlags;
pub type VkDeviceQueueCreateFlags = VkFlags;
pub type VkDeviceQueueGlobalPriorityCreateInfoEXT = VkDeviceQueueGlobalPriorityCreateInfo;
pub type VkDeviceQueueGlobalPriorityCreateInfoKHR = VkDeviceQueueGlobalPriorityCreateInfo;
pub type VkDeviceSize = u64;
pub type VkDirectDriverLoadingFlagsLUNARG = VkFlags;
pub type VkDirectDriverLoadingModeLUNARG = i32;
pub type VkDiscardRectangleModeEXT = i32;
pub type VkDisplayEventTypeEXT = i32;
pub type VkDisplayKHR = *mut VkDisplayKHR_T;
pub type VkDisplayModeCreateFlagsKHR = VkFlags;
pub type VkDisplayModeKHR = *mut VkDisplayModeKHR_T;
pub type VkDisplayPlaneAlphaFlagBitsKHR = VkFlags;
pub type VkDisplayPlaneAlphaFlagsKHR = VkFlags;
pub type VkDisplayPowerStateEXT = i32;
pub type VkDisplaySurfaceCreateFlagsKHR = VkFlags;
pub type VkDisplaySurfaceStereoTypeNV = i32;
pub type VkDriverId = i32;
pub type VkDriverIdKHR = VkDriverId;
pub type VkDynamicState = i32;
pub type VkEvent = *mut VkEvent_T;
pub type VkEventCreateFlagBits = VkFlags;
pub type VkEventCreateFlags = VkFlags;
pub type VkExportFenceCreateInfoKHR = VkExportFenceCreateInfo;
pub type VkExportMemoryAllocateInfoKHR = VkExportMemoryAllocateInfo;
pub type VkExportSemaphoreCreateInfoKHR = VkExportSemaphoreCreateInfo;
pub type VkExternalBufferPropertiesKHR = VkExternalBufferProperties;
pub type VkExternalComputeQueueNV = *mut VkExternalComputeQueueNV_T;
pub type VkExternalFenceFeatureFlagBits = VkFlags;
pub type VkExternalFenceFeatureFlagBitsKHR = VkExternalFenceFeatureFlagBits;
pub type VkExternalFenceFeatureFlags = VkFlags;
pub type VkExternalFenceFeatureFlagsKHR = VkExternalFenceFeatureFlags;
pub type VkExternalFenceHandleTypeFlagBits = VkFlags;
pub type VkExternalFenceHandleTypeFlagBitsKHR = VkExternalFenceHandleTypeFlagBits;
pub type VkExternalFenceHandleTypeFlags = VkFlags;
pub type VkExternalFenceHandleTypeFlagsKHR = VkExternalFenceHandleTypeFlags;
pub type VkExternalFencePropertiesKHR = VkExternalFenceProperties;
pub type VkExternalImageFormatPropertiesKHR = VkExternalImageFormatProperties;
pub type VkExternalMemoryBufferCreateInfoKHR = VkExternalMemoryBufferCreateInfo;
pub type VkExternalMemoryFeatureFlagBits = VkFlags;
pub type VkExternalMemoryFeatureFlagBitsKHR = VkExternalMemoryFeatureFlagBits;
pub type VkExternalMemoryFeatureFlagBitsNV = VkFlags;
pub type VkExternalMemoryFeatureFlags = VkFlags;
pub type VkExternalMemoryFeatureFlagsKHR = VkExternalMemoryFeatureFlags;
pub type VkExternalMemoryFeatureFlagsNV = VkFlags;
pub type VkExternalMemoryHandleTypeFlagBits = VkFlags;
pub type VkExternalMemoryHandleTypeFlagBitsKHR = VkExternalMemoryHandleTypeFlagBits;
pub type VkExternalMemoryHandleTypeFlagBitsNV = VkFlags;
pub type VkExternalMemoryHandleTypeFlags = VkFlags;
pub type VkExternalMemoryHandleTypeFlagsKHR = VkExternalMemoryHandleTypeFlags;
pub type VkExternalMemoryHandleTypeFlagsNV = VkFlags;
pub type VkExternalMemoryImageCreateInfoKHR = VkExternalMemoryImageCreateInfo;
pub type VkExternalMemoryPropertiesKHR = VkExternalMemoryProperties;
pub type VkExternalSemaphoreFeatureFlagBits = VkFlags;
pub type VkExternalSemaphoreFeatureFlagBitsKHR = VkExternalSemaphoreFeatureFlagBits;
pub type VkExternalSemaphoreFeatureFlags = VkFlags;
pub type VkExternalSemaphoreFeatureFlagsKHR = VkExternalSemaphoreFeatureFlags;
pub type VkExternalSemaphoreHandleTypeFlagBits = VkFlags;
pub type VkExternalSemaphoreHandleTypeFlagBitsKHR = VkExternalSemaphoreHandleTypeFlagBits;
pub type VkExternalSemaphoreHandleTypeFlags = VkFlags;
pub type VkExternalSemaphoreHandleTypeFlagsKHR = VkExternalSemaphoreHandleTypeFlags;
pub type VkExternalSemaphorePropertiesKHR = VkExternalSemaphoreProperties;
pub type VkFence = *mut VkFence_T;
pub type VkFenceCreateFlagBits = VkFlags;
pub type VkFenceCreateFlags = VkFlags;
pub type VkFenceImportFlagBits = VkFlags;
pub type VkFenceImportFlagBitsKHR = VkFenceImportFlagBits;
pub type VkFenceImportFlags = VkFlags;
pub type VkFenceImportFlagsKHR = VkFenceImportFlags;
pub type VkFilter = i32;
pub type VkFlags = u32;
pub type VkFlags64 = u64;
pub type VkFormat = i32;
pub type VkFormatFeatureFlagBits = VkFlags;
pub type VkFormatFeatureFlagBits2 = VkFlags64;
pub type VkFormatFeatureFlagBits2KHR = VkFormatFeatureFlagBits2;
pub type VkFormatFeatureFlags = VkFlags;
pub type VkFormatFeatureFlags2 = VkFlags64;
pub type VkFormatFeatureFlags2KHR = VkFormatFeatureFlags2;
pub type VkFormatProperties2KHR = VkFormatProperties2;
pub type VkFormatProperties3KHR = VkFormatProperties3;
pub type VkFragmentShadingRateCombinerOpKHR = i32;
pub type VkFragmentShadingRateNV = i32;
pub type VkFragmentShadingRateTypeNV = i32;
pub type VkFrameBoundaryFlagBitsEXT = VkFlags;
pub type VkFrameBoundaryFlagsEXT = VkFlags;
pub type VkFramebuffer = *mut VkFramebuffer_T;
pub type VkFramebufferAttachmentImageInfoKHR = VkFramebufferAttachmentImageInfo;
pub type VkFramebufferAttachmentsCreateInfoKHR = VkFramebufferAttachmentsCreateInfo;
pub type VkFramebufferCreateFlagBits = VkFlags;
pub type VkFramebufferCreateFlags = VkFlags;
pub type VkFrontFace = i32;
pub type VkGeometryFlagBitsKHR = VkFlags;
pub type VkGeometryFlagBitsNV = VkGeometryFlagBitsKHR;
pub type VkGeometryFlagsKHR = VkFlags;
pub type VkGeometryFlagsNV = VkGeometryFlagsKHR;
pub type VkGeometryInstanceFlagBitsKHR = VkFlags;
pub type VkGeometryInstanceFlagBitsNV = VkGeometryInstanceFlagBitsKHR;
pub type VkGeometryInstanceFlagsKHR = VkFlags;
pub type VkGeometryInstanceFlagsNV = VkGeometryInstanceFlagsKHR;
pub type VkGeometryTypeKHR = i32;
pub type VkGeometryTypeNV = VkGeometryTypeKHR;
pub type VkGraphicsPipelineLibraryFlagBitsEXT = VkFlags;
pub type VkGraphicsPipelineLibraryFlagsEXT = VkFlags;
pub type VkHeadlessSurfaceCreateFlagsEXT = VkFlags;
pub type VkHostImageCopyDevicePerformanceQueryEXT = VkHostImageCopyDevicePerformanceQuery;
pub type VkHostImageCopyFlagBits = VkFlags;
pub type VkHostImageCopyFlagBitsEXT = VkHostImageCopyFlagBits;
pub type VkHostImageCopyFlags = VkFlags;
pub type VkHostImageCopyFlagsEXT = VkHostImageCopyFlags;
pub type VkHostImageLayoutTransitionInfoEXT = VkHostImageLayoutTransitionInfo;
pub type VkImage = *mut VkImage_T;
pub type VkImageAspectFlagBits = VkFlags;
pub type VkImageAspectFlags = VkFlags;
pub type VkImageBlit2KHR = VkImageBlit2;
pub type VkImageCompressionFixedRateFlagBitsEXT = VkFlags;
pub type VkImageCompressionFixedRateFlagsEXT = VkFlags;
pub type VkImageCompressionFlagBitsEXT = VkFlags;
pub type VkImageCompressionFlagsEXT = VkFlags;
pub type VkImageCopy2KHR = VkImageCopy2;
pub type VkImageCreateFlagBits = VkFlags;
pub type VkImageCreateFlags = VkFlags;
pub type VkImageFormatListCreateInfoKHR = VkImageFormatListCreateInfo;
pub type VkImageFormatProperties2KHR = VkImageFormatProperties2;
pub type VkImageLayout = i32;
pub type VkImageMemoryBarrier2KHR = VkImageMemoryBarrier2;
pub type VkImageMemoryRequirementsInfo2KHR = VkImageMemoryRequirementsInfo2;
pub type VkImagePlaneMemoryRequirementsInfoKHR = VkImagePlaneMemoryRequirementsInfo;
pub type VkImageResolve2KHR = VkImageResolve2;
pub type VkImageSparseMemoryRequirementsInfo2KHR = VkImageSparseMemoryRequirementsInfo2;
pub type VkImageStencilUsageCreateInfoEXT = VkImageStencilUsageCreateInfo;
pub type VkImageSubresource2EXT = VkImageSubresource2;
pub type VkImageSubresource2KHR = VkImageSubresource2;
pub type VkImageTiling = i32;
pub type VkImageToMemoryCopyEXT = VkImageToMemoryCopy;
pub type VkImageType = i32;
pub type VkImageUsageFlagBits = VkFlags;
pub type VkImageUsageFlags = VkFlags;
pub type VkImageView = *mut VkImageView_T;
pub type VkImageViewCreateFlagBits = VkFlags;
pub type VkImageViewCreateFlags = VkFlags;
pub type VkImageViewType = i32;
pub type VkImageViewUsageCreateInfoKHR = VkImageViewUsageCreateInfo;
pub type VkIndexType = i32;
pub type VkIndirectCommandsInputModeFlagBitsEXT = VkFlags;
pub type VkIndirectCommandsInputModeFlagsEXT = VkFlags;
pub type VkIndirectCommandsLayoutEXT = *mut VkIndirectCommandsLayoutEXT_T;
pub type VkIndirectCommandsLayoutNV = *mut VkIndirectCommandsLayoutNV_T;
pub type VkIndirectCommandsLayoutUsageFlagBitsEXT = VkFlags;
pub type VkIndirectCommandsLayoutUsageFlagBitsNV = VkFlags;
pub type VkIndirectCommandsLayoutUsageFlagsEXT = VkFlags;
pub type VkIndirectCommandsLayoutUsageFlagsNV = VkFlags;
pub type VkIndirectCommandsTokenTypeEXT = i32;
pub type VkIndirectCommandsTokenTypeNV = i32;
pub type VkIndirectExecutionSetEXT = *mut VkIndirectExecutionSetEXT_T;
pub type VkIndirectExecutionSetInfoTypeEXT = i32;
pub type VkIndirectStateFlagBitsNV = VkFlags;
pub type VkIndirectStateFlagsNV = VkFlags;
pub type VkInputAttachmentAspectReferenceKHR = VkInputAttachmentAspectReference;
pub type VkInstance = *mut VkInstance_T;
pub type VkInstanceCreateFlagBits = VkFlags;
pub type VkInstanceCreateFlags = VkFlags;
pub type VkInternalAllocationType = i32;
pub type VkLatencyMarkerNV = i32;
pub type VkLayerSettingTypeEXT = i32;
pub type VkLayeredDriverUnderlyingApiMSFT = i32;
pub type VkLineRasterizationMode = i32;
pub type VkLineRasterizationModeEXT = VkLineRasterizationMode;
pub type VkLineRasterizationModeKHR = VkLineRasterizationMode;
pub type VkLogicOp = i32;
pub type VkMemoryAllocateFlagBits = VkFlags;
pub type VkMemoryAllocateFlagBitsKHR = VkMemoryAllocateFlagBits;
pub type VkMemoryAllocateFlags = VkFlags;
pub type VkMemoryAllocateFlagsInfoKHR = VkMemoryAllocateFlagsInfo;
pub type VkMemoryAllocateFlagsKHR = VkMemoryAllocateFlags;
pub type VkMemoryBarrier2KHR = VkMemoryBarrier2;
pub type VkMemoryDecompressionMethodFlagBitsEXT = VkFlags64;
pub type VkMemoryDecompressionMethodFlagBitsNV = VkMemoryDecompressionMethodFlagBitsEXT;
pub type VkMemoryDecompressionMethodFlagsEXT = VkFlags64;
pub type VkMemoryDecompressionMethodFlagsNV = VkMemoryDecompressionMethodFlagsEXT;
pub type VkMemoryDedicatedAllocateInfoKHR = VkMemoryDedicatedAllocateInfo;
pub type VkMemoryDedicatedRequirementsKHR = VkMemoryDedicatedRequirements;
pub type VkMemoryHeapFlagBits = VkFlags;
pub type VkMemoryHeapFlags = VkFlags;
pub type VkMemoryMapFlagBits = VkFlags;
pub type VkMemoryMapFlags = VkFlags;
pub type VkMemoryMapInfoKHR = VkMemoryMapInfo;
pub type VkMemoryOpaqueCaptureAddressAllocateInfoKHR = VkMemoryOpaqueCaptureAddressAllocateInfo;
pub type VkMemoryOverallocationBehaviorAMD = i32;
pub type VkMemoryPropertyFlagBits = VkFlags;
pub type VkMemoryPropertyFlags = VkFlags;
pub type VkMemoryRequirements2KHR = VkMemoryRequirements2;
pub type VkMemoryToImageCopyEXT = VkMemoryToImageCopy;
pub type VkMemoryUnmapFlagBits = VkFlags;
pub type VkMemoryUnmapFlagBitsKHR = VkMemoryUnmapFlagBits;
pub type VkMemoryUnmapFlags = VkFlags;
pub type VkMemoryUnmapFlagsKHR = VkMemoryUnmapFlags;
pub type VkMemoryUnmapInfoKHR = VkMemoryUnmapInfo;
pub type VkMicromapCreateFlagBitsEXT = VkFlags;
pub type VkMicromapCreateFlagsEXT = VkFlags;
pub type VkMicromapEXT = *mut VkMicromapEXT_T;
pub type VkMicromapTypeEXT = i32;
pub type VkMutableDescriptorTypeCreateInfoVALVE = VkMutableDescriptorTypeCreateInfoEXT;
pub type VkMutableDescriptorTypeListVALVE = VkMutableDescriptorTypeListEXT;
pub type VkObjectType = i32;
pub type VkOpacityMicromapFormatEXT = i32;
pub type VkOpacityMicromapSpecialIndexEXT = i32;
pub type VkOpticalFlowExecuteFlagBitsNV = VkFlags;
pub type VkOpticalFlowExecuteFlagsNV = VkFlags;
pub type VkOpticalFlowGridSizeFlagBitsNV = VkFlags;
pub type VkOpticalFlowGridSizeFlagsNV = VkFlags;
pub type VkOpticalFlowPerformanceLevelNV = i32;
pub type VkOpticalFlowSessionBindingPointNV = i32;
pub type VkOpticalFlowSessionCreateFlagBitsNV = VkFlags;
pub type VkOpticalFlowSessionCreateFlagsNV = VkFlags;
pub type VkOpticalFlowSessionNV = *mut VkOpticalFlowSessionNV_T;
pub type VkOpticalFlowUsageFlagBitsNV = VkFlags;
pub type VkOpticalFlowUsageFlagsNV = VkFlags;
pub type VkOutOfBandQueueTypeNV = i32;
pub type VkPartitionedAccelerationStructureInstanceFlagBitsNV = VkFlags;
pub type VkPartitionedAccelerationStructureInstanceFlagsNV = VkFlags;
pub type VkPartitionedAccelerationStructureOpTypeNV = i32;
pub type VkPastPresentationTimingFlagBitsEXT = VkFlags;
pub type VkPastPresentationTimingFlagsEXT = VkFlags;
pub type VkPeerMemoryFeatureFlagBits = VkFlags;
pub type VkPeerMemoryFeatureFlagBitsKHR = VkPeerMemoryFeatureFlagBits;
pub type VkPeerMemoryFeatureFlags = VkFlags;
pub type VkPeerMemoryFeatureFlagsKHR = VkPeerMemoryFeatureFlags;
pub type VkPerformanceConfigurationINTEL = *mut VkPerformanceConfigurationINTEL_T;
pub type VkPerformanceConfigurationTypeINTEL = i32;
pub type VkPerformanceCounterDescriptionFlagBitsKHR = VkFlags;
pub type VkPerformanceCounterDescriptionFlagsARM = VkFlags;
pub type VkPerformanceCounterDescriptionFlagsKHR = VkFlags;
pub type VkPerformanceCounterScopeKHR = i32;
pub type VkPerformanceCounterStorageKHR = i32;
pub type VkPerformanceCounterUnitKHR = i32;
pub type VkPerformanceOverrideTypeINTEL = i32;
pub type VkPerformanceParameterTypeINTEL = i32;
pub type VkPerformanceValueTypeINTEL = i32;
pub type VkPhysicalDevice = *mut VkPhysicalDevice_T;
pub type VkPhysicalDevice16BitStorageFeaturesKHR = VkPhysicalDevice16BitStorageFeatures;
pub type VkPhysicalDevice8BitStorageFeaturesKHR = VkPhysicalDevice8BitStorageFeatures;
pub type VkPhysicalDeviceBufferAddressFeaturesEXT = VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;
pub type VkPhysicalDeviceBufferDeviceAddressFeaturesKHR = VkPhysicalDeviceBufferDeviceAddressFeatures;
pub type VkPhysicalDeviceComputeShaderDerivativesFeaturesNV = VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR;
pub type VkPhysicalDeviceCopyMemoryIndirectPropertiesNV = VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR;
pub type VkPhysicalDeviceDataGraphOperationTypeARM = i32;
pub type VkPhysicalDeviceDataGraphProcessingEngineTypeARM = i32;
pub type VkPhysicalDeviceDepthClampZeroOneFeaturesEXT = VkPhysicalDeviceDepthClampZeroOneFeaturesKHR;
pub type VkPhysicalDeviceDepthStencilResolvePropertiesKHR = VkPhysicalDeviceDepthStencilResolveProperties;
pub type VkPhysicalDeviceDescriptorIndexingFeaturesEXT = VkPhysicalDeviceDescriptorIndexingFeatures;
pub type VkPhysicalDeviceDescriptorIndexingPropertiesEXT = VkPhysicalDeviceDescriptorIndexingProperties;
pub type VkPhysicalDeviceDriverPropertiesKHR = VkPhysicalDeviceDriverProperties;
pub type VkPhysicalDeviceDynamicRenderingFeaturesKHR = VkPhysicalDeviceDynamicRenderingFeatures;
pub type VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR = VkPhysicalDeviceDynamicRenderingLocalReadFeatures;
pub type VkPhysicalDeviceExternalBufferInfoKHR = VkPhysicalDeviceExternalBufferInfo;
pub type VkPhysicalDeviceExternalFenceInfoKHR = VkPhysicalDeviceExternalFenceInfo;
pub type VkPhysicalDeviceExternalImageFormatInfoKHR = VkPhysicalDeviceExternalImageFormatInfo;
pub type VkPhysicalDeviceExternalSemaphoreInfoKHR = VkPhysicalDeviceExternalSemaphoreInfo;
pub type VkPhysicalDeviceFeatures2KHR = VkPhysicalDeviceFeatures2;
pub type VkPhysicalDeviceFloat16Int8FeaturesKHR = VkPhysicalDeviceShaderFloat16Int8Features;
pub type VkPhysicalDeviceFloatControlsPropertiesKHR = VkPhysicalDeviceFloatControlsProperties;
pub type VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
pub type VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
pub type VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV = VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
pub type VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT = VkPhysicalDeviceGlobalPriorityQueryFeatures;
pub type VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR = VkPhysicalDeviceGlobalPriorityQueryFeatures;
pub type VkPhysicalDeviceGroupPropertiesKHR = VkPhysicalDeviceGroupProperties;
pub type VkPhysicalDeviceHostImageCopyFeaturesEXT = VkPhysicalDeviceHostImageCopyFeatures;
pub type VkPhysicalDeviceHostImageCopyPropertiesEXT = VkPhysicalDeviceHostImageCopyProperties;
pub type VkPhysicalDeviceHostQueryResetFeaturesEXT = VkPhysicalDeviceHostQueryResetFeatures;
pub type VkPhysicalDeviceIDPropertiesKHR = VkPhysicalDeviceIDProperties;
pub type VkPhysicalDeviceImageFormatInfo2KHR = VkPhysicalDeviceImageFormatInfo2;
pub type VkPhysicalDeviceImageRobustnessFeaturesEXT = VkPhysicalDeviceImageRobustnessFeatures;
pub type VkPhysicalDeviceImagelessFramebufferFeaturesKHR = VkPhysicalDeviceImagelessFramebufferFeatures;
pub type VkPhysicalDeviceIndexTypeUint8FeaturesEXT = VkPhysicalDeviceIndexTypeUint8Features;
pub type VkPhysicalDeviceIndexTypeUint8FeaturesKHR = VkPhysicalDeviceIndexTypeUint8Features;
pub type VkPhysicalDeviceInlineUniformBlockFeaturesEXT = VkPhysicalDeviceInlineUniformBlockFeatures;
pub type VkPhysicalDeviceInlineUniformBlockPropertiesEXT = VkPhysicalDeviceInlineUniformBlockProperties;
pub type VkPhysicalDeviceLayeredApiKHR = i32;
pub type VkPhysicalDeviceLineRasterizationFeaturesEXT = VkPhysicalDeviceLineRasterizationFeatures;
pub type VkPhysicalDeviceLineRasterizationFeaturesKHR = VkPhysicalDeviceLineRasterizationFeatures;
pub type VkPhysicalDeviceLineRasterizationPropertiesEXT = VkPhysicalDeviceLineRasterizationProperties;
pub type VkPhysicalDeviceLineRasterizationPropertiesKHR = VkPhysicalDeviceLineRasterizationProperties;
pub type VkPhysicalDeviceMaintenance3PropertiesKHR = VkPhysicalDeviceMaintenance3Properties;
pub type VkPhysicalDeviceMaintenance4FeaturesKHR = VkPhysicalDeviceMaintenance4Features;
pub type VkPhysicalDeviceMaintenance4PropertiesKHR = VkPhysicalDeviceMaintenance4Properties;
pub type VkPhysicalDeviceMaintenance5FeaturesKHR = VkPhysicalDeviceMaintenance5Features;
pub type VkPhysicalDeviceMaintenance5PropertiesKHR = VkPhysicalDeviceMaintenance5Properties;
pub type VkPhysicalDeviceMaintenance6FeaturesKHR = VkPhysicalDeviceMaintenance6Features;
pub type VkPhysicalDeviceMaintenance6PropertiesKHR = VkPhysicalDeviceMaintenance6Properties;
pub type VkPhysicalDeviceMemoryDecompressionFeaturesNV = VkPhysicalDeviceMemoryDecompressionFeaturesEXT;
pub type VkPhysicalDeviceMemoryDecompressionPropertiesNV = VkPhysicalDeviceMemoryDecompressionPropertiesEXT;
pub type VkPhysicalDeviceMemoryProperties2KHR = VkPhysicalDeviceMemoryProperties2;
pub type VkPhysicalDeviceMultiviewFeaturesKHR = VkPhysicalDeviceMultiviewFeatures;
pub type VkPhysicalDeviceMultiviewPropertiesKHR = VkPhysicalDeviceMultiviewProperties;
pub type VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE = VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT;
pub type VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT = VkPhysicalDevicePipelineCreationCacheControlFeatures;
pub type VkPhysicalDevicePipelineProtectedAccessFeaturesEXT = VkPhysicalDevicePipelineProtectedAccessFeatures;
pub type VkPhysicalDevicePipelineRobustnessFeaturesEXT = VkPhysicalDevicePipelineRobustnessFeatures;
pub type VkPhysicalDevicePipelineRobustnessPropertiesEXT = VkPhysicalDevicePipelineRobustnessProperties;
pub type VkPhysicalDevicePointClippingPropertiesKHR = VkPhysicalDevicePointClippingProperties;
pub type VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR;
pub type VkPhysicalDevicePrivateDataFeaturesEXT = VkPhysicalDevicePrivateDataFeatures;
pub type VkPhysicalDeviceProperties2KHR = VkPhysicalDeviceProperties2;
pub type VkPhysicalDevicePushDescriptorPropertiesKHR = VkPhysicalDevicePushDescriptorProperties;
pub type VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
pub type VkPhysicalDeviceRobustness2FeaturesEXT = VkPhysicalDeviceRobustness2FeaturesKHR;
pub type VkPhysicalDeviceRobustness2PropertiesEXT = VkPhysicalDeviceRobustness2PropertiesKHR;
pub type VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT = VkPhysicalDeviceSamplerFilterMinmaxProperties;
pub type VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VkPhysicalDeviceSamplerYcbcrConversionFeatures;
pub type VkPhysicalDeviceScalarBlockLayoutFeaturesEXT = VkPhysicalDeviceScalarBlockLayoutFeatures;
pub type VkPhysicalDeviceSchedulingControlsFlagBitsARM = VkFlags64;
pub type VkPhysicalDeviceSchedulingControlsFlagsARM = VkFlags64;
pub type VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures;
pub type VkPhysicalDeviceShaderAtomicInt64FeaturesKHR = VkPhysicalDeviceShaderAtomicInt64Features;
pub type VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures;
pub type VkPhysicalDeviceShaderDrawParameterFeatures = VkPhysicalDeviceShaderDrawParametersFeatures;
pub type VkPhysicalDeviceShaderExpectAssumeFeaturesKHR = VkPhysicalDeviceShaderExpectAssumeFeatures;
pub type VkPhysicalDeviceShaderFloat16Int8FeaturesKHR = VkPhysicalDeviceShaderFloat16Int8Features;
pub type VkPhysicalDeviceShaderFloatControls2FeaturesKHR = VkPhysicalDeviceShaderFloatControls2Features;
pub type VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR = VkPhysicalDeviceShaderIntegerDotProductFeatures;
pub type VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR = VkPhysicalDeviceShaderIntegerDotProductProperties;
pub type VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures;
pub type VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR = VkPhysicalDeviceShaderSubgroupRotateFeatures;
pub type VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR = VkPhysicalDeviceShaderTerminateInvocationFeatures;
pub type VkPhysicalDeviceSparseImageFormatInfo2KHR = VkPhysicalDeviceSparseImageFormatInfo2;
pub type VkPhysicalDeviceSubgroupSizeControlFeaturesEXT = VkPhysicalDeviceSubgroupSizeControlFeatures;
pub type VkPhysicalDeviceSubgroupSizeControlPropertiesEXT = VkPhysicalDeviceSubgroupSizeControlProperties;
pub type VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT = VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR;
pub type VkPhysicalDeviceSynchronization2FeaturesKHR = VkPhysicalDeviceSynchronization2Features;
pub type VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT = VkPhysicalDeviceTexelBufferAlignmentProperties;
pub type VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = VkPhysicalDeviceTextureCompressionASTCHDRFeatures;
pub type VkPhysicalDeviceTimelineSemaphoreFeaturesKHR = VkPhysicalDeviceTimelineSemaphoreFeatures;
pub type VkPhysicalDeviceTimelineSemaphorePropertiesKHR = VkPhysicalDeviceTimelineSemaphoreProperties;
pub type VkPhysicalDeviceToolPropertiesEXT = VkPhysicalDeviceToolProperties;
pub type VkPhysicalDeviceType = i32;
pub type VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = VkPhysicalDeviceUniformBufferStandardLayoutFeatures;
pub type VkPhysicalDeviceVariablePointerFeatures = VkPhysicalDeviceVariablePointersFeatures;
pub type VkPhysicalDeviceVariablePointerFeaturesKHR = VkPhysicalDeviceVariablePointersFeatures;
pub type VkPhysicalDeviceVariablePointersFeaturesKHR = VkPhysicalDeviceVariablePointersFeatures;
pub type VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT = VkPhysicalDeviceVertexAttributeDivisorFeatures;
pub type VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR = VkPhysicalDeviceVertexAttributeDivisorFeatures;
pub type VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR = VkPhysicalDeviceVertexAttributeDivisorProperties;
pub type VkPhysicalDeviceVulkanMemoryModelFeaturesKHR = VkPhysicalDeviceVulkanMemoryModelFeatures;
pub type VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
pub type VkPipeline = *mut VkPipeline_T;
pub type VkPipelineBinaryKHR = *mut VkPipelineBinaryKHR_T;
pub type VkPipelineBindPoint = i32;
pub type VkPipelineCache = *mut VkPipelineCache_T;
pub type VkPipelineCacheCreateFlagBits = VkFlags;
pub type VkPipelineCacheCreateFlags = VkFlags;
pub type VkPipelineCacheHeaderVersion = i32;
pub type VkPipelineColorBlendStateCreateFlagBits = VkFlags;
pub type VkPipelineColorBlendStateCreateFlags = VkFlags;
pub type VkPipelineCompilerControlFlagBitsAMD = VkFlags;
pub type VkPipelineCompilerControlFlagsAMD = VkFlags;
pub type VkPipelineCoverageModulationStateCreateFlagsNV = VkFlags;
pub type VkPipelineCoverageReductionStateCreateFlagsNV = VkFlags;
pub type VkPipelineCoverageToColorStateCreateFlagsNV = VkFlags;
pub type VkPipelineCreateFlagBits = VkFlags;
pub type VkPipelineCreateFlagBits2 = VkFlags64;
pub type VkPipelineCreateFlagBits2KHR = VkPipelineCreateFlagBits2;
pub type VkPipelineCreateFlags = VkFlags;
pub type VkPipelineCreateFlags2 = VkFlags64;
pub type VkPipelineCreateFlags2CreateInfoKHR = VkPipelineCreateFlags2CreateInfo;
pub type VkPipelineCreateFlags2KHR = VkPipelineCreateFlags2;
pub type VkPipelineCreationFeedbackCreateInfoEXT = VkPipelineCreationFeedbackCreateInfo;
pub type VkPipelineCreationFeedbackEXT = VkPipelineCreationFeedback;
pub type VkPipelineCreationFeedbackFlagBits = VkFlags;
pub type VkPipelineCreationFeedbackFlagBitsEXT = VkPipelineCreationFeedbackFlagBits;
pub type VkPipelineCreationFeedbackFlags = VkFlags;
pub type VkPipelineCreationFeedbackFlagsEXT = VkPipelineCreationFeedbackFlags;
pub type VkPipelineDepthStencilStateCreateFlagBits = VkFlags;
pub type VkPipelineDepthStencilStateCreateFlags = VkFlags;
pub type VkPipelineDiscardRectangleStateCreateFlagsEXT = VkFlags;
pub type VkPipelineDynamicStateCreateFlags = VkFlags;
pub type VkPipelineExecutableStatisticFormatKHR = i32;
pub type VkPipelineInfoEXT = VkPipelineInfoKHR;
pub type VkPipelineInputAssemblyStateCreateFlags = VkFlags;
pub type VkPipelineLayout = *mut VkPipelineLayout_T;
pub type VkPipelineLayoutCreateFlagBits = VkFlags;
pub type VkPipelineLayoutCreateFlags = VkFlags;
pub type VkPipelineMultisampleStateCreateFlags = VkFlags;
pub type VkPipelineRasterizationConservativeStateCreateFlagsEXT = VkFlags;
pub type VkPipelineRasterizationDepthClipStateCreateFlagsEXT = VkFlags;
pub type VkPipelineRasterizationLineStateCreateInfoEXT = VkPipelineRasterizationLineStateCreateInfo;
pub type VkPipelineRasterizationLineStateCreateInfoKHR = VkPipelineRasterizationLineStateCreateInfo;
pub type VkPipelineRasterizationStateCreateFlags = VkFlags;
pub type VkPipelineRasterizationStateStreamCreateFlagsEXT = VkFlags;
pub type VkPipelineRenderingCreateInfoKHR = VkPipelineRenderingCreateInfo;
pub type VkPipelineRobustnessBufferBehavior = i32;
pub type VkPipelineRobustnessBufferBehaviorEXT = VkPipelineRobustnessBufferBehavior;
pub type VkPipelineRobustnessCreateInfoEXT = VkPipelineRobustnessCreateInfo;
pub type VkPipelineRobustnessImageBehavior = i32;
pub type VkPipelineRobustnessImageBehaviorEXT = VkPipelineRobustnessImageBehavior;
pub type VkPipelineShaderStageCreateFlagBits = VkFlags;
pub type VkPipelineShaderStageCreateFlags = VkFlags;
pub type VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = VkPipelineShaderStageRequiredSubgroupSizeCreateInfo;
pub type VkPipelineStageFlagBits = VkFlags;
pub type VkPipelineStageFlagBits2 = VkFlags64;
pub type VkPipelineStageFlagBits2KHR = VkPipelineStageFlagBits2;
pub type VkPipelineStageFlags = VkFlags;
pub type VkPipelineStageFlags2 = VkFlags64;
pub type VkPipelineStageFlags2KHR = VkPipelineStageFlags2;
pub type VkPipelineTessellationDomainOriginStateCreateInfoKHR = VkPipelineTessellationDomainOriginStateCreateInfo;
pub type VkPipelineTessellationStateCreateFlags = VkFlags;
pub type VkPipelineVertexInputDivisorStateCreateInfoEXT = VkPipelineVertexInputDivisorStateCreateInfo;
pub type VkPipelineVertexInputDivisorStateCreateInfoKHR = VkPipelineVertexInputDivisorStateCreateInfo;
pub type VkPipelineVertexInputStateCreateFlags = VkFlags;
pub type VkPipelineViewportStateCreateFlags = VkFlags;
pub type VkPipelineViewportSwizzleStateCreateFlagsNV = VkFlags;
pub type VkPointClippingBehavior = i32;
pub type VkPointClippingBehaviorKHR = VkPointClippingBehavior;
pub type VkPolygonMode = i32;
pub type VkPresentGravityFlagBitsEXT = VkPresentGravityFlagBitsKHR;
pub type VkPresentGravityFlagBitsKHR = VkFlags;
pub type VkPresentGravityFlagsEXT = VkPresentGravityFlagsKHR;
pub type VkPresentGravityFlagsKHR = VkFlags;
pub type VkPresentModeKHR = i32;
pub type VkPresentScalingFlagBitsEXT = VkPresentScalingFlagBitsKHR;
pub type VkPresentScalingFlagBitsKHR = VkFlags;
pub type VkPresentScalingFlagsEXT = VkPresentScalingFlagsKHR;
pub type VkPresentScalingFlagsKHR = VkFlags;
pub type VkPresentStageFlagBitsEXT = VkFlags;
pub type VkPresentStageFlagsEXT = VkFlags;
pub type VkPresentTimingInfoFlagBitsEXT = VkFlags;
pub type VkPresentTimingInfoFlagsEXT = VkFlags;
pub type VkPrimitiveTopology = i32;
pub type VkPrivateDataSlot = *mut VkPrivateDataSlot_T;
pub type VkPrivateDataSlotCreateFlags = VkFlags;
pub type VkPrivateDataSlotCreateFlagsEXT = VkPrivateDataSlotCreateFlags;
pub type VkPrivateDataSlotCreateInfoEXT = VkPrivateDataSlotCreateInfo;
pub type VkPrivateDataSlotEXT = *mut VkPrivateDataSlotEXT_T;
pub type VkPrivateDataSlotEXT_T = VkPrivateDataSlot_T;
pub type VkProvokingVertexModeEXT = i32;
pub type VkPushConstantsInfoKHR = VkPushConstantsInfo;
pub type VkPushDescriptorSetInfoKHR = VkPushDescriptorSetInfo;
pub type VkPushDescriptorSetWithTemplateInfoKHR = VkPushDescriptorSetWithTemplateInfo;
pub type VkQueryControlFlagBits = VkFlags;
pub type VkQueryControlFlags = VkFlags;
pub type VkQueryPipelineStatisticFlagBits = VkFlags;
pub type VkQueryPipelineStatisticFlags = VkFlags;
pub type VkQueryPool = *mut VkQueryPool_T;
pub type VkQueryPoolCreateFlagBits = VkFlags;
pub type VkQueryPoolCreateFlags = VkFlags;
pub type VkQueryPoolCreateInfoINTEL = VkQueryPoolPerformanceQueryCreateInfoINTEL;
pub type VkQueryPoolSamplingModeINTEL = i32;
pub type VkQueryResultFlagBits = VkFlags;
pub type VkQueryResultFlags = VkFlags;
pub type VkQueryResultStatusKHR = i32;
pub type VkQueryType = i32;
pub type VkQueue = *mut VkQueue_T;
pub type VkQueueFamilyGlobalPriorityPropertiesEXT = VkQueueFamilyGlobalPriorityProperties;
pub type VkQueueFamilyGlobalPriorityPropertiesKHR = VkQueueFamilyGlobalPriorityProperties;
pub type VkQueueFamilyProperties2KHR = VkQueueFamilyProperties2;
pub type VkQueueFlagBits = VkFlags;
pub type VkQueueFlags = VkFlags;
pub type VkQueueGlobalPriority = i32;
pub type VkQueueGlobalPriorityEXT = VkQueueGlobalPriority;
pub type VkQueueGlobalPriorityKHR = VkQueueGlobalPriority;
pub type VkRasterizationOrderAMD = i32;
pub type VkRayTracingInvocationReorderModeEXT = i32;
pub type VkRayTracingInvocationReorderModeNV = VkRayTracingInvocationReorderModeEXT;
pub type VkRayTracingLssIndexingModeNV = i32;
pub type VkRayTracingLssPrimitiveEndCapsModeNV = i32;
pub type VkRayTracingShaderGroupTypeKHR = i32;
pub type VkRayTracingShaderGroupTypeNV = VkRayTracingShaderGroupTypeKHR;
pub type VkReleaseSwapchainImagesInfoEXT = VkReleaseSwapchainImagesInfoKHR;
pub type VkRemoteAddressNV = *mut c_void;
pub type VkRenderPass = *mut VkRenderPass_T;
pub type VkRenderPassAttachmentBeginInfoKHR = VkRenderPassAttachmentBeginInfo;
pub type VkRenderPassCreateFlagBits = VkFlags;
pub type VkRenderPassCreateFlags = VkFlags;
pub type VkRenderPassCreateInfo2KHR = VkRenderPassCreateInfo2;
pub type VkRenderPassInputAttachmentAspectCreateInfoKHR = VkRenderPassInputAttachmentAspectCreateInfo;
pub type VkRenderPassMultiviewCreateInfoKHR = VkRenderPassMultiviewCreateInfo;
pub type VkRenderingAreaInfoKHR = VkRenderingAreaInfo;
pub type VkRenderingAttachmentFlagBitsKHR = VkFlags;
pub type VkRenderingAttachmentFlagsKHR = VkFlags;
pub type VkRenderingAttachmentInfoKHR = VkRenderingAttachmentInfo;
pub type VkRenderingAttachmentLocationInfoKHR = VkRenderingAttachmentLocationInfo;
pub type VkRenderingEndInfoEXT = VkRenderingEndInfoKHR;
pub type VkRenderingFlagBits = VkFlags;
pub type VkRenderingFlagBitsKHR = VkRenderingFlagBits;
pub type VkRenderingFlags = VkFlags;
pub type VkRenderingFlagsKHR = VkRenderingFlags;
pub type VkRenderingInfoKHR = VkRenderingInfo;
pub type VkRenderingInputAttachmentIndexInfoKHR = VkRenderingInputAttachmentIndexInfo;
pub type VkResolveImageFlagBitsKHR = VkFlags;
pub type VkResolveImageFlagsKHR = VkFlags;
pub type VkResolveImageInfo2KHR = VkResolveImageInfo2;
pub type VkResolveModeFlagBits = VkFlags;
pub type VkResolveModeFlagBitsKHR = VkResolveModeFlagBits;
pub type VkResolveModeFlags = VkFlags;
pub type VkResolveModeFlagsKHR = VkResolveModeFlags;
pub type VkResult = i32;
pub type VkSampleCountFlagBits = VkFlags;
pub type VkSampleCountFlags = VkFlags;
pub type VkSampleMask = u32;
pub type VkSampler = *mut VkSampler_T;
pub type VkSamplerAddressMode = i32;
pub type VkSamplerCreateFlagBits = VkFlags;
pub type VkSamplerCreateFlags = VkFlags;
pub type VkSamplerMipmapMode = i32;
pub type VkSamplerReductionMode = i32;
pub type VkSamplerReductionModeCreateInfoEXT = VkSamplerReductionModeCreateInfo;
pub type VkSamplerReductionModeEXT = VkSamplerReductionMode;
pub type VkSamplerYcbcrConversion = *mut VkSamplerYcbcrConversion_T;
pub type VkSamplerYcbcrConversionCreateInfoKHR = VkSamplerYcbcrConversionCreateInfo;
pub type VkSamplerYcbcrConversionImageFormatPropertiesKHR = VkSamplerYcbcrConversionImageFormatProperties;
pub type VkSamplerYcbcrConversionInfoKHR = VkSamplerYcbcrConversionInfo;
pub type VkSamplerYcbcrConversionKHR = *mut VkSamplerYcbcrConversionKHR_T;
pub type VkSamplerYcbcrConversionKHR_T = VkSamplerYcbcrConversion_T;
pub type VkSamplerYcbcrModelConversion = i32;
pub type VkSamplerYcbcrModelConversionKHR = VkSamplerYcbcrModelConversion;
pub type VkSamplerYcbcrRange = i32;
pub type VkSamplerYcbcrRangeKHR = VkSamplerYcbcrRange;
pub type VkScopeKHR = i32;
pub type VkScopeNV = VkScopeKHR;
pub type VkSemaphore = *mut VkSemaphore_T;
pub type VkSemaphoreCreateFlags = VkFlags;
pub type VkSemaphoreImportFlagBits = VkFlags;
pub type VkSemaphoreImportFlagBitsKHR = VkSemaphoreImportFlagBits;
pub type VkSemaphoreImportFlags = VkFlags;
pub type VkSemaphoreImportFlagsKHR = VkSemaphoreImportFlags;
pub type VkSemaphoreSignalInfoKHR = VkSemaphoreSignalInfo;
pub type VkSemaphoreSubmitInfoKHR = VkSemaphoreSubmitInfo;
pub type VkSemaphoreType = i32;
pub type VkSemaphoreTypeCreateInfoKHR = VkSemaphoreTypeCreateInfo;
pub type VkSemaphoreTypeKHR = VkSemaphoreType;
pub type VkSemaphoreWaitFlagBits = VkFlags;
pub type VkSemaphoreWaitFlagBitsKHR = VkSemaphoreWaitFlagBits;
pub type VkSemaphoreWaitFlags = VkFlags;
pub type VkSemaphoreWaitFlagsKHR = VkSemaphoreWaitFlags;
pub type VkSemaphoreWaitInfoKHR = VkSemaphoreWaitInfo;
pub type VkShaderCodeTypeEXT = i32;
pub type VkShaderCorePropertiesFlagBitsAMD = VkFlags;
pub type VkShaderCorePropertiesFlagsAMD = VkFlags;
pub type VkShaderCreateFlagBitsEXT = VkFlags;
pub type VkShaderCreateFlagsEXT = VkFlags;
pub type VkShaderEXT = *mut VkShaderEXT_T;
pub type VkShaderFloatControlsIndependence = i32;
pub type VkShaderFloatControlsIndependenceKHR = VkShaderFloatControlsIndependence;
pub type VkShaderGroupShaderKHR = i32;
pub type VkShaderInfoTypeAMD = i32;
pub type VkShaderModule = *mut VkShaderModule_T;
pub type VkShaderModuleCreateFlags = VkFlags;
pub type VkShaderRequiredSubgroupSizeCreateInfoEXT = VkPipelineShaderStageRequiredSubgroupSizeCreateInfo;
pub type VkShaderStageFlagBits = VkFlags;
pub type VkShaderStageFlags = VkFlags;
pub type VkShadingRatePaletteEntryNV = i32;
pub type VkSharingMode = i32;
pub type VkSparseImageFormatFlagBits = VkFlags;
pub type VkSparseImageFormatFlags = VkFlags;
pub type VkSparseImageFormatProperties2KHR = VkSparseImageFormatProperties2;
pub type VkSparseImageMemoryRequirements2KHR = VkSparseImageMemoryRequirements2;
pub type VkSparseMemoryBindFlagBits = VkFlags;
pub type VkSparseMemoryBindFlags = VkFlags;
pub type VkStencilFaceFlagBits = VkFlags;
pub type VkStencilFaceFlags = VkFlags;
pub type VkStencilOp = i32;
pub type VkStructureType = i32;
pub type VkSubgroupFeatureFlagBits = VkFlags;
pub type VkSubgroupFeatureFlags = VkFlags;
pub type VkSubmitFlagBits = VkFlags;
pub type VkSubmitFlagBitsKHR = VkSubmitFlagBits;
pub type VkSubmitFlags = VkFlags;
pub type VkSubmitFlagsKHR = VkSubmitFlags;
pub type VkSubmitInfo2KHR = VkSubmitInfo2;
pub type VkSubpassBeginInfoKHR = VkSubpassBeginInfo;
pub type VkSubpassContents = i32;
pub type VkSubpassDependency2KHR = VkSubpassDependency2;
pub type VkSubpassDescription2KHR = VkSubpassDescription2;
pub type VkSubpassDescriptionDepthStencilResolveKHR = VkSubpassDescriptionDepthStencilResolve;
pub type VkSubpassDescriptionFlagBits = VkFlags;
pub type VkSubpassDescriptionFlags = VkFlags;
pub type VkSubpassEndInfoKHR = VkSubpassEndInfo;
pub type VkSubpassFragmentDensityMapOffsetEndInfoQCOM = VkRenderPassFragmentDensityMapOffsetEndInfoEXT;
pub type VkSubpassMergeStatusEXT = i32;
pub type VkSubresourceHostMemcpySizeEXT = VkSubresourceHostMemcpySize;
pub type VkSubresourceLayout2EXT = VkSubresourceLayout2;
pub type VkSubresourceLayout2KHR = VkSubresourceLayout2;
pub type VkSurfaceCounterFlagBitsEXT = VkFlags;
pub type VkSurfaceCounterFlagsEXT = VkFlags;
pub type VkSurfaceKHR = *mut VkSurfaceKHR_T;
pub type VkSurfacePresentModeCompatibilityEXT = VkSurfacePresentModeCompatibilityKHR;
pub type VkSurfacePresentModeEXT = VkSurfacePresentModeKHR;
pub type VkSurfacePresentScalingCapabilitiesEXT = VkSurfacePresentScalingCapabilitiesKHR;
pub type VkSurfaceTransformFlagBitsKHR = VkFlags;
pub type VkSurfaceTransformFlagsKHR = VkFlags;
pub type VkSwapchainCreateFlagBitsKHR = VkFlags;
pub type VkSwapchainCreateFlagsKHR = VkFlags;
pub type VkSwapchainKHR = *mut VkSwapchainKHR_T;
pub type VkSwapchainPresentFenceInfoEXT = VkSwapchainPresentFenceInfoKHR;
pub type VkSwapchainPresentModeInfoEXT = VkSwapchainPresentModeInfoKHR;
pub type VkSwapchainPresentModesCreateInfoEXT = VkSwapchainPresentModesCreateInfoKHR;
pub type VkSwapchainPresentScalingCreateInfoEXT = VkSwapchainPresentScalingCreateInfoKHR;
pub type VkSystemAllocationScope = i32;
pub type VkTensorARM = *mut VkTensorARM_T;
pub type VkTensorCreateFlagBitsARM = VkFlags64;
pub type VkTensorCreateFlagsARM = VkFlags64;
pub type VkTensorTilingARM = i32;
pub type VkTensorUsageFlagBitsARM = VkFlags64;
pub type VkTensorUsageFlagsARM = VkFlags64;
pub type VkTensorViewARM = *mut VkTensorViewARM_T;
pub type VkTensorViewCreateFlagBitsARM = VkFlags64;
pub type VkTensorViewCreateFlagsARM = VkFlags64;
pub type VkTessellationDomainOrigin = i32;
pub type VkTessellationDomainOriginKHR = VkTessellationDomainOrigin;
pub type VkTileShadingRenderPassFlagBitsQCOM = VkFlags;
pub type VkTileShadingRenderPassFlagsQCOM = VkFlags;
pub type VkTimeDomainEXT = VkTimeDomainKHR;
pub type VkTimeDomainKHR = i32;
pub type VkTimelineSemaphoreSubmitInfoKHR = VkTimelineSemaphoreSubmitInfo;
pub type VkToolPurposeFlagBits = VkFlags;
pub type VkToolPurposeFlagBitsEXT = VkToolPurposeFlagBits;
pub type VkToolPurposeFlags = VkFlags;
pub type VkToolPurposeFlagsEXT = VkToolPurposeFlags;
pub type VkTransformMatrixNV = VkTransformMatrixKHR;
pub type VkValidationCacheCreateFlagsEXT = VkFlags;
pub type VkValidationCacheEXT = *mut VkValidationCacheEXT_T;
pub type VkValidationCacheHeaderVersionEXT = i32;
pub type VkValidationCheckEXT = i32;
pub type VkValidationFeatureDisableEXT = i32;
pub type VkValidationFeatureEnableEXT = i32;
pub type VkVendorId = i32;
pub type VkVertexInputBindingDivisorDescriptionEXT = VkVertexInputBindingDivisorDescription;
pub type VkVertexInputBindingDivisorDescriptionKHR = VkVertexInputBindingDivisorDescription;
pub type VkVertexInputRate = i32;
pub type VkVideoBeginCodingFlagsKHR = VkFlags;
pub type VkVideoCapabilityFlagBitsKHR = VkFlags;
pub type VkVideoCapabilityFlagsKHR = VkFlags;
pub type VkVideoChromaSubsamplingFlagBitsKHR = VkFlags;
pub type VkVideoChromaSubsamplingFlagsKHR = VkFlags;
pub type VkVideoCodecOperationFlagBitsKHR = VkFlags;
pub type VkVideoCodecOperationFlagsKHR = VkFlags;
pub type VkVideoCodingControlFlagBitsKHR = VkFlags;
pub type VkVideoCodingControlFlagsKHR = VkFlags;
pub type VkVideoComponentBitDepthFlagBitsKHR = VkFlags;
pub type VkVideoComponentBitDepthFlagsKHR = VkFlags;
pub type VkVideoDecodeCapabilityFlagBitsKHR = VkFlags;
pub type VkVideoDecodeCapabilityFlagsKHR = VkFlags;
pub type VkVideoDecodeFlagsKHR = VkFlags;
pub type VkVideoDecodeH264PictureLayoutFlagBitsKHR = VkFlags;
pub type VkVideoDecodeH264PictureLayoutFlagsKHR = VkFlags;
pub type VkVideoDecodeUsageFlagBitsKHR = VkFlags;
pub type VkVideoDecodeUsageFlagsKHR = VkFlags;
pub type VkVideoEncodeAV1CapabilityFlagBitsKHR = VkFlags;
pub type VkVideoEncodeAV1CapabilityFlagsKHR = VkFlags;
pub type VkVideoEncodeAV1PredictionModeKHR = i32;
pub type VkVideoEncodeAV1RateControlFlagBitsKHR = VkFlags;
pub type VkVideoEncodeAV1RateControlFlagsKHR = VkFlags;
pub type VkVideoEncodeAV1RateControlGroupKHR = i32;
pub type VkVideoEncodeAV1StdFlagBitsKHR = VkFlags;
pub type VkVideoEncodeAV1StdFlagsKHR = VkFlags;
pub type VkVideoEncodeAV1SuperblockSizeFlagBitsKHR = VkFlags;
pub type VkVideoEncodeAV1SuperblockSizeFlagsKHR = VkFlags;
pub type VkVideoEncodeCapabilityFlagBitsKHR = VkFlags;
pub type VkVideoEncodeCapabilityFlagsKHR = VkFlags;
pub type VkVideoEncodeContentFlagBitsKHR = VkFlags;
pub type VkVideoEncodeContentFlagsKHR = VkFlags;
pub type VkVideoEncodeFeedbackFlagBitsKHR = VkFlags;
pub type VkVideoEncodeFeedbackFlagsKHR = VkFlags;
pub type VkVideoEncodeFlagBitsKHR = VkFlags;
pub type VkVideoEncodeFlagsKHR = VkFlags;
pub type VkVideoEncodeH264CapabilityFlagBitsKHR = VkFlags;
pub type VkVideoEncodeH264CapabilityFlagsKHR = VkFlags;
pub type VkVideoEncodeH264RateControlFlagBitsKHR = VkFlags;
pub type VkVideoEncodeH264RateControlFlagsKHR = VkFlags;
pub type VkVideoEncodeH264StdFlagBitsKHR = VkFlags;
pub type VkVideoEncodeH264StdFlagsKHR = VkFlags;
pub type VkVideoEncodeH265CapabilityFlagBitsKHR = VkFlags;
pub type VkVideoEncodeH265CapabilityFlagsKHR = VkFlags;
pub type VkVideoEncodeH265CtbSizeFlagBitsKHR = VkFlags;
pub type VkVideoEncodeH265CtbSizeFlagsKHR = VkFlags;
pub type VkVideoEncodeH265RateControlFlagBitsKHR = VkFlags;
pub type VkVideoEncodeH265RateControlFlagsKHR = VkFlags;
pub type VkVideoEncodeH265StdFlagBitsKHR = VkFlags;
pub type VkVideoEncodeH265StdFlagsKHR = VkFlags;
pub type VkVideoEncodeH265TransformBlockSizeFlagBitsKHR = VkFlags;
pub type VkVideoEncodeH265TransformBlockSizeFlagsKHR = VkFlags;
pub type VkVideoEncodeIntraRefreshModeFlagBitsKHR = VkFlags;
pub type VkVideoEncodeIntraRefreshModeFlagsKHR = VkFlags;
pub type VkVideoEncodeRateControlFlagsKHR = VkFlags;
pub type VkVideoEncodeRateControlModeFlagBitsKHR = VkFlags;
pub type VkVideoEncodeRateControlModeFlagsKHR = VkFlags;
pub type VkVideoEncodeRgbChromaOffsetFlagBitsVALVE = VkFlags;
pub type VkVideoEncodeRgbChromaOffsetFlagsVALVE = VkFlags;
pub type VkVideoEncodeRgbModelConversionFlagBitsVALVE = VkFlags;
pub type VkVideoEncodeRgbModelConversionFlagsVALVE = VkFlags;
pub type VkVideoEncodeRgbRangeCompressionFlagBitsVALVE = VkFlags;
pub type VkVideoEncodeRgbRangeCompressionFlagsVALVE = VkFlags;
pub type VkVideoEncodeTuningModeKHR = i32;
pub type VkVideoEncodeUsageFlagBitsKHR = VkFlags;
pub type VkVideoEncodeUsageFlagsKHR = VkFlags;
pub type VkVideoEndCodingFlagsKHR = VkFlags;
pub type VkVideoSessionCreateFlagBitsKHR = VkFlags;
pub type VkVideoSessionCreateFlagsKHR = VkFlags;
pub type VkVideoSessionKHR = *mut VkVideoSessionKHR_T;
pub type VkVideoSessionParametersCreateFlagBitsKHR = VkFlags;
pub type VkVideoSessionParametersCreateFlagsKHR = VkFlags;
pub type VkVideoSessionParametersKHR = *mut VkVideoSessionParametersKHR_T;
pub type VkViewportCoordinateSwizzleNV = i32;
pub type VkWriteDescriptorSetInlineUniformBlockEXT = VkWriteDescriptorSetInlineUniformBlock;

#[derive(Clone, Copy)]
#[repr(C)]
pub union VkAccelerationStructureGeometryDataKHR {
    pub triangles: VkAccelerationStructureGeometryTrianglesDataKHR,
    pub aabbs: VkAccelerationStructureGeometryAabbsDataKHR,
    pub instances: VkAccelerationStructureGeometryInstancesDataKHR,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub union VkAccelerationStructureMotionInstanceDataNV {
    pub staticInstance: VkAccelerationStructureInstanceKHR,
    pub matrixMotionInstance: VkAccelerationStructureMatrixMotionInstanceNV,
    pub srtMotionInstance: VkAccelerationStructureSRTMotionInstanceNV,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub union VkClearColorValue {
    pub float32: [f32; 4 as usize],
    pub int32: [i32; 4 as usize],
    pub uint32: [u32; 4 as usize],
}

#[derive(Clone, Copy)]
#[repr(C)]
pub union VkClearValue {
    pub color: VkClearColorValue,
    pub depthStencil: VkClearDepthStencilValue,
}

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

#[derive(Clone, Copy)]
#[repr(C)]
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,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub union VkDeviceOrHostAddressConstKHR {
    pub deviceAddress: VkDeviceAddress,
    pub hostAddress: *const c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub union VkDeviceOrHostAddressKHR {
    pub deviceAddress: VkDeviceAddress,
    pub hostAddress: *mut c_void,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub union VkIndirectCommandsTokenDataEXT {
    pub pPushConstant: *const VkIndirectCommandsPushConstantTokenEXT,
    pub pVertexBuffer: *const VkIndirectCommandsVertexBufferTokenEXT,
    pub pIndexBuffer: *const VkIndirectCommandsIndexBufferTokenEXT,
    pub pExecutionSet: *const VkIndirectCommandsExecutionSetTokenEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub union VkIndirectExecutionSetInfoEXT {
    pub pPipelineInfo: *const VkIndirectExecutionSetPipelineInfoEXT,
    pub pShaderInfo: *const VkIndirectExecutionSetShaderInfoEXT,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub union VkPerformanceCounterResultKHR {
    pub int32: i32,
    pub int64: i64,
    pub uint32: u32,
    pub uint64: u64,
    pub float32: f32,
    pub float64: f64,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub union VkPerformanceValueDataINTEL {
    pub value32: u32,
    pub value64: u64,
    pub valueFloat: f32,
    pub valueBool: VkBool32,
    pub valueString: *const c_char,
}

#[derive(Clone, Copy)]
#[repr(C)]
pub union VkPipelineExecutableStatisticValueKHR {
    pub b32: VkBool32,
    pub i64: i64,
    pub u64: u64,
    pub f64: f64,
}