vulkanalia_sys/

structs.rs

// SPDX-License-Identifier: Apache-2.0

// DO NOT EDIT.
//
// This file has been generated by the Kotlin project in the `generator`
// directory from a Vulkan API registry.

#![allow(
    non_camel_case_types,
    non_snake_case,
    clippy::bad_bit_mask,
    clippy::let_unit_value,
    clippy::missing_safety_doc,
    clippy::missing_transmute_annotations,
    clippy::too_many_arguments,
    clippy::type_complexity,
    clippy::unnecessary_cast,
    clippy::upper_case_acronyms,
    clippy::useless_transmute
)]

use core::ffi::{c_char, c_int, c_void};
use core::fmt;
use core::ptr;

use crate::*;

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAabbPositionsKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq)]
pub struct AabbPositionsKHR {
    pub min_x: f32,
    pub min_y: f32,
    pub min_z: f32,
    pub max_x: f32,
    pub max_y: f32,
    pub max_z: f32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureBuildGeometryInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureBuildGeometryInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub type_: AccelerationStructureTypeKHR,
    pub flags: BuildAccelerationStructureFlagsKHR,
    pub mode: BuildAccelerationStructureModeKHR,
    pub src_acceleration_structure: AccelerationStructureKHR,
    pub dst_acceleration_structure: AccelerationStructureKHR,
    pub geometry_count: u32,
    pub geometries: *const AccelerationStructureGeometryKHR,
    pub pointer_geometries: *const *const AccelerationStructureGeometryKHR,
    pub scratch_data: DeviceOrHostAddressKHR,
}

impl Default for AccelerationStructureBuildGeometryInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR,
            next: ptr::null(),
            type_: AccelerationStructureTypeKHR::default(),
            flags: BuildAccelerationStructureFlagsKHR::default(),
            mode: BuildAccelerationStructureModeKHR::default(),
            src_acceleration_structure: AccelerationStructureKHR::default(),
            dst_acceleration_structure: AccelerationStructureKHR::default(),
            geometry_count: u32::default(),
            geometries: ptr::null(),
            pointer_geometries: ptr::null(),
            scratch_data: DeviceOrHostAddressKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureBuildRangeInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct AccelerationStructureBuildRangeInfoKHR {
    pub primitive_count: u32,
    pub primitive_offset: u32,
    pub first_vertex: u32,
    pub transform_offset: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureBuildSizesInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AccelerationStructureBuildSizesInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub acceleration_structure_size: DeviceSize,
    pub update_scratch_size: DeviceSize,
    pub build_scratch_size: DeviceSize,
}

impl Default for AccelerationStructureBuildSizesInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR,
            next: ptr::null(),
            acceleration_structure_size: DeviceSize::default(),
            update_scratch_size: DeviceSize::default(),
            build_scratch_size: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureCaptureDescriptorDataInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AccelerationStructureCaptureDescriptorDataInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub acceleration_structure: AccelerationStructureKHR,
    pub acceleration_structure_nv: AccelerationStructureNV,
}

impl Default for AccelerationStructureCaptureDescriptorDataInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT,
            next: ptr::null(),
            acceleration_structure: AccelerationStructureKHR::default(),
            acceleration_structure_nv: AccelerationStructureNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AccelerationStructureCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub create_flags: AccelerationStructureCreateFlagsKHR,
    pub buffer: Buffer,
    pub offset: DeviceSize,
    pub size: DeviceSize,
    pub type_: AccelerationStructureTypeKHR,
    pub device_address: DeviceAddress,
}

impl Default for AccelerationStructureCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_KHR,
            next: ptr::null(),
            create_flags: AccelerationStructureCreateFlagsKHR::default(),
            buffer: Buffer::default(),
            offset: DeviceSize::default(),
            size: DeviceSize::default(),
            type_: AccelerationStructureTypeKHR::default(),
            device_address: DeviceAddress::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AccelerationStructureCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub compacted_size: DeviceSize,
    pub info: AccelerationStructureInfoNV,
}

impl Default for AccelerationStructureCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_NV,
            next: ptr::null(),
            compacted_size: DeviceSize::default(),
            info: AccelerationStructureInfoNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureDeviceAddressInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AccelerationStructureDeviceAddressInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub acceleration_structure: AccelerationStructureKHR,
}

impl Default for AccelerationStructureDeviceAddressInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR,
            next: ptr::null(),
            acceleration_structure: AccelerationStructureKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryAabbsDataKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureGeometryAabbsDataKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub data: DeviceOrHostAddressConstKHR,
    pub stride: DeviceSize,
}

impl Default for AccelerationStructureGeometryAabbsDataKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR,
            next: ptr::null(),
            data: DeviceOrHostAddressConstKHR::default(),
            stride: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryInstancesDataKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureGeometryInstancesDataKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub array_of_pointers: Bool32,
    pub data: DeviceOrHostAddressConstKHR,
}

impl Default for AccelerationStructureGeometryInstancesDataKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR,
            next: ptr::null(),
            array_of_pointers: Bool32::default(),
            data: DeviceOrHostAddressConstKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureGeometryKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub geometry_type: GeometryTypeKHR,
    pub geometry: AccelerationStructureGeometryDataKHR,
    pub flags: GeometryFlagsKHR,
}

impl Default for AccelerationStructureGeometryKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_KHR,
            next: ptr::null(),
            geometry_type: GeometryTypeKHR::default(),
            geometry: AccelerationStructureGeometryDataKHR::default(),
            flags: GeometryFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryLinearSweptSpheresDataNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureGeometryLinearSweptSpheresDataNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub vertex_format: Format,
    pub vertex_data: DeviceOrHostAddressConstKHR,
    pub vertex_stride: DeviceSize,
    pub radius_format: Format,
    pub radius_data: DeviceOrHostAddressConstKHR,
    pub radius_stride: DeviceSize,
    pub index_type: IndexType,
    pub index_data: DeviceOrHostAddressConstKHR,
    pub index_stride: DeviceSize,
    pub indexing_mode: RayTracingLssIndexingModeNV,
    pub end_caps_mode: RayTracingLssPrimitiveEndCapsModeNV,
}

impl Default for AccelerationStructureGeometryLinearSweptSpheresDataNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV,
            next: ptr::null(),
            vertex_format: Format::default(),
            vertex_data: DeviceOrHostAddressConstKHR::default(),
            vertex_stride: DeviceSize::default(),
            radius_format: Format::default(),
            radius_data: DeviceOrHostAddressConstKHR::default(),
            radius_stride: DeviceSize::default(),
            index_type: IndexType::default(),
            index_data: DeviceOrHostAddressConstKHR::default(),
            index_stride: DeviceSize::default(),
            indexing_mode: RayTracingLssIndexingModeNV::default(),
            end_caps_mode: RayTracingLssPrimitiveEndCapsModeNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryMotionTrianglesDataNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureGeometryMotionTrianglesDataNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub vertex_data: DeviceOrHostAddressConstKHR,
}

impl Default for AccelerationStructureGeometryMotionTrianglesDataNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV,
            next: ptr::null(),
            vertex_data: DeviceOrHostAddressConstKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureGeometrySpheresDataNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureGeometrySpheresDataNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub vertex_format: Format,
    pub vertex_data: DeviceOrHostAddressConstKHR,
    pub vertex_stride: DeviceSize,
    pub radius_format: Format,
    pub radius_data: DeviceOrHostAddressConstKHR,
    pub radius_stride: DeviceSize,
    pub index_type: IndexType,
    pub index_data: DeviceOrHostAddressConstKHR,
    pub index_stride: DeviceSize,
}

impl Default for AccelerationStructureGeometrySpheresDataNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV,
            next: ptr::null(),
            vertex_format: Format::default(),
            vertex_data: DeviceOrHostAddressConstKHR::default(),
            vertex_stride: DeviceSize::default(),
            radius_format: Format::default(),
            radius_data: DeviceOrHostAddressConstKHR::default(),
            radius_stride: DeviceSize::default(),
            index_type: IndexType::default(),
            index_data: DeviceOrHostAddressConstKHR::default(),
            index_stride: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryTrianglesDataKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureGeometryTrianglesDataKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub vertex_format: Format,
    pub vertex_data: DeviceOrHostAddressConstKHR,
    pub vertex_stride: DeviceSize,
    pub max_vertex: u32,
    pub index_type: IndexType,
    pub index_data: DeviceOrHostAddressConstKHR,
    pub transform_data: DeviceOrHostAddressConstKHR,
}

impl Default for AccelerationStructureGeometryTrianglesDataKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR,
            next: ptr::null(),
            vertex_format: Format::default(),
            vertex_data: DeviceOrHostAddressConstKHR::default(),
            vertex_stride: DeviceSize::default(),
            max_vertex: u32::default(),
            index_type: IndexType::default(),
            index_data: DeviceOrHostAddressConstKHR::default(),
            transform_data: DeviceOrHostAddressConstKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AccelerationStructureInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub type_: AccelerationStructureTypeNV,
    pub flags: BuildAccelerationStructureFlagsNV,
    pub instance_count: u32,
    pub geometry_count: u32,
    pub geometries: *const GeometryNV,
}

impl Default for AccelerationStructureInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_INFO_NV,
            next: ptr::null(),
            type_: AccelerationStructureTypeNV::default(),
            flags: BuildAccelerationStructureFlagsNV::default(),
            instance_count: u32::default(),
            geometry_count: u32::default(),
            geometries: ptr::null(),
        }
    }
}

bitfields32! {
    struct AccelerationStructureInstanceKHRBitfields0 {
        (instance_custom_index, with_instance_custom_index)[0 .. 24],
        (mask, with_mask)[24 .. 32],
    }
}

bitfields32! {
    struct AccelerationStructureInstanceKHRBitfields1 {
        (instance_shader_binding_table_record_offset, with_instance_shader_binding_table_record_offset)[0 .. 24],
        (flags, with_flags)[24 .. 32],
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureInstanceKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq)]
pub struct AccelerationStructureInstanceKHR {
    pub transform: TransformMatrixKHR,
    pub acceleration_structure_reference: u64,
    pub bitfields0: AccelerationStructureInstanceKHRBitfields0,
    pub bitfields1: AccelerationStructureInstanceKHRBitfields1,
}

bitfields32! {
    struct AccelerationStructureMatrixMotionInstanceNVBitfields0 {
        (instance_custom_index, with_instance_custom_index)[0 .. 24],
        (mask, with_mask)[24 .. 32],
    }
}

bitfields32! {
    struct AccelerationStructureMatrixMotionInstanceNVBitfields1 {
        (instance_shader_binding_table_record_offset, with_instance_shader_binding_table_record_offset)[0 .. 24],
        (flags, with_flags)[24 .. 32],
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureMatrixMotionInstanceNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq)]
pub struct AccelerationStructureMatrixMotionInstanceNV {
    pub transform_t0: TransformMatrixKHR,
    pub transform_t1: TransformMatrixKHR,
    pub acceleration_structure_reference: u64,
    pub bitfields0: AccelerationStructureMatrixMotionInstanceNVBitfields0,
    pub bitfields1: AccelerationStructureMatrixMotionInstanceNVBitfields1,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureMemoryRequirementsInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AccelerationStructureMemoryRequirementsInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub type_: AccelerationStructureMemoryRequirementsTypeNV,
    pub acceleration_structure: AccelerationStructureNV,
}

impl Default for AccelerationStructureMemoryRequirementsInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV,
            next: ptr::null(),
            type_: AccelerationStructureMemoryRequirementsTypeNV::default(),
            acceleration_structure: AccelerationStructureNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AccelerationStructureMotionInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub max_instances: u32,
    pub flags: AccelerationStructureMotionInfoFlagsNV,
}

impl Default for AccelerationStructureMotionInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_MOTION_INFO_NV,
            next: ptr::null(),
            max_instances: u32::default(),
            flags: AccelerationStructureMotionInfoFlagsNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInstanceNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
pub struct AccelerationStructureMotionInstanceNV {
    pub type_: AccelerationStructureMotionInstanceTypeNV,
    pub flags: AccelerationStructureMotionInstanceFlagsNV,
    pub data: AccelerationStructureMotionInstanceDataNV,
}

bitfields32! {
    struct AccelerationStructureSRTMotionInstanceNVBitfields0 {
        (instance_custom_index, with_instance_custom_index)[0 .. 24],
        (mask, with_mask)[24 .. 32],
    }
}

bitfields32! {
    struct AccelerationStructureSRTMotionInstanceNVBitfields1 {
        (instance_shader_binding_table_record_offset, with_instance_shader_binding_table_record_offset)[0 .. 24],
        (flags, with_flags)[24 .. 32],
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureSRTMotionInstanceNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq)]
pub struct AccelerationStructureSRTMotionInstanceNV {
    pub transform_t0: SRTDataNV,
    pub transform_t1: SRTDataNV,
    pub acceleration_structure_reference: u64,
    pub bitfields0: AccelerationStructureSRTMotionInstanceNVBitfields0,
    pub bitfields1: AccelerationStructureSRTMotionInstanceNVBitfields1,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureTrianglesDisplacementMicromapNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureTrianglesDisplacementMicromapNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub displacement_bias_and_scale_format: Format,
    pub displacement_vector_format: Format,
    pub displacement_bias_and_scale_buffer: DeviceOrHostAddressConstKHR,
    pub displacement_bias_and_scale_stride: DeviceSize,
    pub displacement_vector_buffer: DeviceOrHostAddressConstKHR,
    pub displacement_vector_stride: DeviceSize,
    pub displaced_micromap_primitive_flags: DeviceOrHostAddressConstKHR,
    pub displaced_micromap_primitive_flags_stride: DeviceSize,
    pub index_type: IndexType,
    pub index_buffer: DeviceOrHostAddressConstKHR,
    pub index_stride: DeviceSize,
    pub base_triangle: u32,
    pub usage_counts_count: u32,
    pub usage_counts: *const MicromapUsageEXT,
    pub pointer_usage_counts: *const *const MicromapUsageEXT,
    pub micromap: MicromapEXT,
}

impl Default for AccelerationStructureTrianglesDisplacementMicromapNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV,
            next: ptr::null_mut(),
            displacement_bias_and_scale_format: Format::default(),
            displacement_vector_format: Format::default(),
            displacement_bias_and_scale_buffer: DeviceOrHostAddressConstKHR::default(),
            displacement_bias_and_scale_stride: DeviceSize::default(),
            displacement_vector_buffer: DeviceOrHostAddressConstKHR::default(),
            displacement_vector_stride: DeviceSize::default(),
            displaced_micromap_primitive_flags: DeviceOrHostAddressConstKHR::default(),
            displaced_micromap_primitive_flags_stride: DeviceSize::default(),
            index_type: IndexType::default(),
            index_buffer: DeviceOrHostAddressConstKHR::default(),
            index_stride: DeviceSize::default(),
            base_triangle: u32::default(),
            usage_counts_count: u32::default(),
            usage_counts: ptr::null(),
            pointer_usage_counts: ptr::null(),
            micromap: MicromapEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureTrianglesOpacityMicromapEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureTrianglesOpacityMicromapEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub index_type: IndexType,
    pub index_buffer: DeviceOrHostAddressConstKHR,
    pub index_stride: DeviceSize,
    pub base_triangle: u32,
    pub usage_counts_count: u32,
    pub usage_counts: *const MicromapUsageEXT,
    pub pointer_usage_counts: *const *const MicromapUsageEXT,
    pub micromap: MicromapEXT,
}

impl Default for AccelerationStructureTrianglesOpacityMicromapEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT,
            next: ptr::null_mut(),
            index_type: IndexType::default(),
            index_buffer: DeviceOrHostAddressConstKHR::default(),
            index_stride: DeviceSize::default(),
            base_triangle: u32::default(),
            usage_counts_count: u32::default(),
            usage_counts: ptr::null(),
            pointer_usage_counts: ptr::null(),
            micromap: MicromapEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureVersionInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AccelerationStructureVersionInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub version_data: *const u8,
}

impl Default for AccelerationStructureVersionInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACCELERATION_STRUCTURE_VERSION_INFO_KHR,
            next: ptr::null(),
            version_data: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAcquireNextImageInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AcquireNextImageInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub swapchain: SwapchainKHR,
    pub timeout: u64,
    pub semaphore: Semaphore,
    pub fence: Fence,
    pub device_mask: u32,
}

impl Default for AcquireNextImageInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACQUIRE_NEXT_IMAGE_INFO_KHR,
            next: ptr::null(),
            swapchain: SwapchainKHR::default(),
            timeout: u64::default(),
            semaphore: Semaphore::default(),
            fence: Fence::default(),
            device_mask: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAcquireProfilingLockInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AcquireProfilingLockInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: AcquireProfilingLockFlagsKHR,
    pub timeout: u64,
}

impl Default for AcquireProfilingLockInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ACQUIRE_PROFILING_LOCK_INFO_KHR,
            next: ptr::null(),
            flags: AcquireProfilingLockFlagsKHR::default(),
            timeout: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAllocationCallbacks.html>
#[repr(C)]
#[derive(Copy, Clone)]
pub struct AllocationCallbacks {
    pub user_data: *mut c_void,
    pub allocation: PFN_vkAllocationFunction,
    pub reallocation: PFN_vkReallocationFunction,
    pub free: PFN_vkFreeFunction,
    pub internal_allocation: PFN_vkInternalAllocationNotification,
    pub internal_free: PFN_vkInternalFreeNotification,
}

impl fmt::Debug for AllocationCallbacks {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("AllocationCallbacks")
            .field("user_data", &self.user_data)
            .field("allocation", &(self.allocation.map(|f| f as *const u8)))
            .field("reallocation", &(self.reallocation.map(|f| f as *const u8)))
            .field("free", &(self.free.map(|f| f as *const u8)))
            .field(
                "internal_allocation",
                &(self.internal_allocation.map(|f| f as *const u8)),
            )
            .field(
                "internal_free",
                &(self.internal_free.map(|f| f as *const u8)),
            )
            .finish()
    }
}

impl Default for AllocationCallbacks {
    #[inline]
    fn default() -> Self {
        Self {
            user_data: ptr::null_mut(),
            allocation: PFN_vkAllocationFunction::default(),
            reallocation: PFN_vkReallocationFunction::default(),
            free: PFN_vkFreeFunction::default(),
            internal_allocation: PFN_vkInternalAllocationNotification::default(),
            internal_free: PFN_vkInternalFreeNotification::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAmigoProfilingSubmitInfoSEC.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AmigoProfilingSubmitInfoSEC {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub first_draw_timestamp: u64,
    pub swap_buffer_timestamp: u64,
}

impl Default for AmigoProfilingSubmitInfoSEC {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::AMIGO_PROFILING_SUBMIT_INFO_SEC,
            next: ptr::null(),
            first_draw_timestamp: u64::default(),
            swap_buffer_timestamp: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAndroidHardwareBufferFormatProperties2ANDROID.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AndroidHardwareBufferFormatProperties2ANDROID {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub format: Format,
    pub external_format: u64,
    pub format_features: FormatFeatureFlags2,
    pub sampler_ycbcr_conversion_components: ComponentMapping,
    pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
    pub suggested_ycbcr_range: SamplerYcbcrRange,
    pub suggested_x_chroma_offset: ChromaLocation,
    pub suggested_y_chroma_offset: ChromaLocation,
}

impl Default for AndroidHardwareBufferFormatProperties2ANDROID {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID,
            next: ptr::null_mut(),
            format: Format::default(),
            external_format: u64::default(),
            format_features: FormatFeatureFlags2::default(),
            sampler_ycbcr_conversion_components: ComponentMapping::default(),
            suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
            suggested_ycbcr_range: SamplerYcbcrRange::default(),
            suggested_x_chroma_offset: ChromaLocation::default(),
            suggested_y_chroma_offset: ChromaLocation::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAndroidHardwareBufferFormatPropertiesANDROID.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AndroidHardwareBufferFormatPropertiesANDROID {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub format: Format,
    pub external_format: u64,
    pub format_features: FormatFeatureFlags,
    pub sampler_ycbcr_conversion_components: ComponentMapping,
    pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
    pub suggested_ycbcr_range: SamplerYcbcrRange,
    pub suggested_x_chroma_offset: ChromaLocation,
    pub suggested_y_chroma_offset: ChromaLocation,
}

impl Default for AndroidHardwareBufferFormatPropertiesANDROID {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID,
            next: ptr::null_mut(),
            format: Format::default(),
            external_format: u64::default(),
            format_features: FormatFeatureFlags::default(),
            sampler_ycbcr_conversion_components: ComponentMapping::default(),
            suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
            suggested_ycbcr_range: SamplerYcbcrRange::default(),
            suggested_x_chroma_offset: ChromaLocation::default(),
            suggested_y_chroma_offset: ChromaLocation::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAndroidHardwareBufferFormatResolvePropertiesANDROID.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AndroidHardwareBufferFormatResolvePropertiesANDROID {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub color_attachment_format: Format,
}

impl Default for AndroidHardwareBufferFormatResolvePropertiesANDROID {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID,
            next: ptr::null_mut(),
            color_attachment_format: Format::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAndroidHardwareBufferPropertiesANDROID.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AndroidHardwareBufferPropertiesANDROID {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub allocation_size: DeviceSize,
    pub memory_type_bits: u32,
}

impl Default for AndroidHardwareBufferPropertiesANDROID {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
            next: ptr::null_mut(),
            allocation_size: DeviceSize::default(),
            memory_type_bits: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAndroidHardwareBufferUsageANDROID.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AndroidHardwareBufferUsageANDROID {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub android_hardware_buffer_usage: u64,
}

impl Default for AndroidHardwareBufferUsageANDROID {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID,
            next: ptr::null_mut(),
            android_hardware_buffer_usage: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAndroidSurfaceCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AndroidSurfaceCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: AndroidSurfaceCreateFlagsKHR,
    pub window: *mut ANativeWindow,
}

impl Default for AndroidSurfaceCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ANDROID_SURFACE_CREATE_INFO_KHR,
            next: ptr::null(),
            flags: AndroidSurfaceCreateFlagsKHR::default(),
            window: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAntiLagDataAMD.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AntiLagDataAMD {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub mode: AntiLagModeAMD,
    pub max_fps: u32,
    pub presentation_info: *const AntiLagPresentationInfoAMD,
}

impl Default for AntiLagDataAMD {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ANTI_LAG_DATA_AMD,
            next: ptr::null(),
            mode: AntiLagModeAMD::default(),
            max_fps: u32::default(),
            presentation_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAntiLagPresentationInfoAMD.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AntiLagPresentationInfoAMD {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub stage: AntiLagStageAMD,
    pub frame_index: u64,
}

impl Default for AntiLagPresentationInfoAMD {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ANTI_LAG_PRESENTATION_INFO_AMD,
            next: ptr::null_mut(),
            stage: AntiLagStageAMD::default(),
            frame_index: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkApplicationInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ApplicationInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub application_name: *const c_char,
    pub application_version: u32,
    pub engine_name: *const c_char,
    pub engine_version: u32,
    pub api_version: u32,
}

impl Default for ApplicationInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::APPLICATION_INFO,
            next: ptr::null(),
            application_name: ptr::null(),
            application_version: u32::default(),
            engine_name: ptr::null(),
            engine_version: u32::default(),
            api_version: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkApplicationParametersEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ApplicationParametersEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub vendor_id: u32,
    pub device_id: u32,
    pub key: u32,
    pub value: u64,
}

impl Default for ApplicationParametersEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::APPLICATION_PARAMETERS_EXT,
            next: ptr::null(),
            vendor_id: u32::default(),
            device_id: u32::default(),
            key: u32::default(),
            value: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAttachmentDescription.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct AttachmentDescription {
    pub flags: AttachmentDescriptionFlags,
    pub format: Format,
    pub samples: SampleCountFlags,
    pub load_op: AttachmentLoadOp,
    pub store_op: AttachmentStoreOp,
    pub stencil_load_op: AttachmentLoadOp,
    pub stencil_store_op: AttachmentStoreOp,
    pub initial_layout: ImageLayout,
    pub final_layout: ImageLayout,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAttachmentDescription2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AttachmentDescription2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: AttachmentDescriptionFlags,
    pub format: Format,
    pub samples: SampleCountFlags,
    pub load_op: AttachmentLoadOp,
    pub store_op: AttachmentStoreOp,
    pub stencil_load_op: AttachmentLoadOp,
    pub stencil_store_op: AttachmentStoreOp,
    pub initial_layout: ImageLayout,
    pub final_layout: ImageLayout,
}

impl Default for AttachmentDescription2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ATTACHMENT_DESCRIPTION_2,
            next: ptr::null(),
            flags: AttachmentDescriptionFlags::default(),
            format: Format::default(),
            samples: SampleCountFlags::default(),
            load_op: AttachmentLoadOp::default(),
            store_op: AttachmentStoreOp::default(),
            stencil_load_op: AttachmentLoadOp::default(),
            stencil_store_op: AttachmentStoreOp::default(),
            initial_layout: ImageLayout::default(),
            final_layout: ImageLayout::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAttachmentDescriptionStencilLayout.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AttachmentDescriptionStencilLayout {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub stencil_initial_layout: ImageLayout,
    pub stencil_final_layout: ImageLayout,
}

impl Default for AttachmentDescriptionStencilLayout {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT,
            next: ptr::null_mut(),
            stencil_initial_layout: ImageLayout::default(),
            stencil_final_layout: ImageLayout::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAttachmentReference.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct AttachmentReference {
    pub attachment: u32,
    pub layout: ImageLayout,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAttachmentReference2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AttachmentReference2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub attachment: u32,
    pub layout: ImageLayout,
    pub aspect_mask: ImageAspectFlags,
}

impl Default for AttachmentReference2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ATTACHMENT_REFERENCE_2,
            next: ptr::null(),
            attachment: u32::default(),
            layout: ImageLayout::default(),
            aspect_mask: ImageAspectFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAttachmentReferenceStencilLayout.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AttachmentReferenceStencilLayout {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub stencil_layout: ImageLayout,
}

impl Default for AttachmentReferenceStencilLayout {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ATTACHMENT_REFERENCE_STENCIL_LAYOUT,
            next: ptr::null_mut(),
            stencil_layout: ImageLayout::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAttachmentSampleCountInfoAMD.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct AttachmentSampleCountInfoAMD {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub color_attachment_count: u32,
    pub color_attachment_samples: *const SampleCountFlags,
    pub depth_stencil_attachment_samples: SampleCountFlags,
}

impl Default for AttachmentSampleCountInfoAMD {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::ATTACHMENT_SAMPLE_COUNT_INFO_AMD,
            next: ptr::null(),
            color_attachment_count: u32::default(),
            color_attachment_samples: ptr::null(),
            depth_stencil_attachment_samples: SampleCountFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAttachmentSampleLocationsEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct AttachmentSampleLocationsEXT {
    pub attachment_index: u32,
    pub sample_locations_info: SampleLocationsInfoEXT,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBaseInStructure.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BaseInStructure {
    pub s_type: StructureType,
    pub next: *const BaseInStructure,
}

impl Default for BaseInStructure {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::default(),
            next: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBaseOutStructure.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BaseOutStructure {
    pub s_type: StructureType,
    pub next: *mut BaseOutStructure,
}

impl Default for BaseOutStructure {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::default(),
            next: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindAccelerationStructureMemoryInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BindAccelerationStructureMemoryInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub acceleration_structure: AccelerationStructureNV,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
    pub device_index_count: u32,
    pub device_indices: *const u32,
}

impl Default for BindAccelerationStructureMemoryInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV,
            next: ptr::null(),
            acceleration_structure: AccelerationStructureNV::default(),
            memory: DeviceMemory::default(),
            memory_offset: DeviceSize::default(),
            device_index_count: u32::default(),
            device_indices: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindBufferMemoryDeviceGroupInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BindBufferMemoryDeviceGroupInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub device_index_count: u32,
    pub device_indices: *const u32,
}

impl Default for BindBufferMemoryDeviceGroupInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
            next: ptr::null(),
            device_index_count: u32::default(),
            device_indices: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindBufferMemoryInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BindBufferMemoryInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub buffer: Buffer,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
}

impl Default for BindBufferMemoryInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BIND_BUFFER_MEMORY_INFO,
            next: ptr::null(),
            buffer: Buffer::default(),
            memory: DeviceMemory::default(),
            memory_offset: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindDescriptorBufferEmbeddedSamplersInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BindDescriptorBufferEmbeddedSamplersInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub stage_flags: ShaderStageFlags,
    pub layout: PipelineLayout,
    pub set: u32,
}

impl Default for BindDescriptorBufferEmbeddedSamplersInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT,
            next: ptr::null(),
            stage_flags: ShaderStageFlags::default(),
            layout: PipelineLayout::default(),
            set: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindDescriptorSetsInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BindDescriptorSetsInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub stage_flags: ShaderStageFlags,
    pub layout: PipelineLayout,
    pub first_set: u32,
    pub descriptor_set_count: u32,
    pub descriptor_sets: *const DescriptorSet,
    pub dynamic_offset_count: u32,
    pub dynamic_offsets: *const u32,
}

impl Default for BindDescriptorSetsInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BIND_DESCRIPTOR_SETS_INFO,
            next: ptr::null(),
            stage_flags: ShaderStageFlags::default(),
            layout: PipelineLayout::default(),
            first_set: u32::default(),
            descriptor_set_count: u32::default(),
            descriptor_sets: ptr::null(),
            dynamic_offset_count: u32::default(),
            dynamic_offsets: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindImageMemoryDeviceGroupInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BindImageMemoryDeviceGroupInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub device_index_count: u32,
    pub device_indices: *const u32,
    pub split_instance_bind_region_count: u32,
    pub split_instance_bind_regions: *const Rect2D,
}

impl Default for BindImageMemoryDeviceGroupInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
            next: ptr::null(),
            device_index_count: u32::default(),
            device_indices: ptr::null(),
            split_instance_bind_region_count: u32::default(),
            split_instance_bind_regions: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindImageMemoryInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BindImageMemoryInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub image: Image,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
}

impl Default for BindImageMemoryInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BIND_IMAGE_MEMORY_INFO,
            next: ptr::null(),
            image: Image::default(),
            memory: DeviceMemory::default(),
            memory_offset: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindImageMemorySwapchainInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BindImageMemorySwapchainInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub swapchain: SwapchainKHR,
    pub image_index: u32,
}

impl Default for BindImageMemorySwapchainInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR,
            next: ptr::null(),
            swapchain: SwapchainKHR::default(),
            image_index: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindImagePlaneMemoryInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BindImagePlaneMemoryInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub plane_aspect: ImageAspectFlags,
}

impl Default for BindImagePlaneMemoryInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BIND_IMAGE_PLANE_MEMORY_INFO,
            next: ptr::null(),
            plane_aspect: ImageAspectFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindIndexBufferIndirectCommandEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct BindIndexBufferIndirectCommandEXT {
    pub buffer_address: DeviceAddress,
    pub size: u32,
    pub index_type: IndexType,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindIndexBufferIndirectCommandNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct BindIndexBufferIndirectCommandNV {
    pub buffer_address: DeviceAddress,
    pub size: u32,
    pub index_type: IndexType,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindMemoryStatus.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BindMemoryStatus {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub result: *mut Result,
}

impl Default for BindMemoryStatus {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BIND_MEMORY_STATUS,
            next: ptr::null(),
            result: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindPipelineIndirectCommandNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct BindPipelineIndirectCommandNV {
    pub pipeline_address: DeviceAddress,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindShaderGroupIndirectCommandNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct BindShaderGroupIndirectCommandNV {
    pub group_index: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindSparseInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BindSparseInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub wait_semaphore_count: u32,
    pub wait_semaphores: *const Semaphore,
    pub buffer_bind_count: u32,
    pub buffer_binds: *const SparseBufferMemoryBindInfo,
    pub image_opaque_bind_count: u32,
    pub image_opaque_binds: *const SparseImageOpaqueMemoryBindInfo,
    pub image_bind_count: u32,
    pub image_binds: *const SparseImageMemoryBindInfo,
    pub signal_semaphore_count: u32,
    pub signal_semaphores: *const Semaphore,
}

impl Default for BindSparseInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BIND_SPARSE_INFO,
            next: ptr::null(),
            wait_semaphore_count: u32::default(),
            wait_semaphores: ptr::null(),
            buffer_bind_count: u32::default(),
            buffer_binds: ptr::null(),
            image_opaque_bind_count: u32::default(),
            image_opaque_binds: ptr::null(),
            image_bind_count: u32::default(),
            image_binds: ptr::null(),
            signal_semaphore_count: u32::default(),
            signal_semaphores: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindVertexBufferIndirectCommandEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct BindVertexBufferIndirectCommandEXT {
    pub buffer_address: DeviceAddress,
    pub size: u32,
    pub stride: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindVertexBufferIndirectCommandNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct BindVertexBufferIndirectCommandNV {
    pub buffer_address: DeviceAddress,
    pub size: u32,
    pub stride: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindVideoSessionMemoryInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BindVideoSessionMemoryInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub memory_bind_index: u32,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
    pub memory_size: DeviceSize,
}

impl Default for BindVideoSessionMemoryInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BIND_VIDEO_SESSION_MEMORY_INFO_KHR,
            next: ptr::null(),
            memory_bind_index: u32::default(),
            memory: DeviceMemory::default(),
            memory_offset: DeviceSize::default(),
            memory_size: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBlitImageCubicWeightsInfoQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BlitImageCubicWeightsInfoQCOM {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub cubic_weights: CubicFilterWeightsQCOM,
}

impl Default for BlitImageCubicWeightsInfoQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM,
            next: ptr::null(),
            cubic_weights: CubicFilterWeightsQCOM::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBlitImageInfo2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BlitImageInfo2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_image: Image,
    pub src_image_layout: ImageLayout,
    pub dst_image: Image,
    pub dst_image_layout: ImageLayout,
    pub region_count: u32,
    pub regions: *const ImageBlit2,
    pub filter: Filter,
}

impl Default for BlitImageInfo2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BLIT_IMAGE_INFO_2,
            next: ptr::null(),
            src_image: Image::default(),
            src_image_layout: ImageLayout::default(),
            dst_image: Image::default(),
            dst_image_layout: ImageLayout::default(),
            region_count: u32::default(),
            regions: ptr::null(),
            filter: Filter::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferCaptureDescriptorDataInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferCaptureDescriptorDataInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub buffer: Buffer,
}

impl Default for BufferCaptureDescriptorDataInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT,
            next: ptr::null(),
            buffer: Buffer::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferCollectionBufferCreateInfoFUCHSIA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferCollectionBufferCreateInfoFUCHSIA {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub collection: BufferCollectionFUCHSIA,
    pub index: u32,
}

impl Default for BufferCollectionBufferCreateInfoFUCHSIA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA,
            next: ptr::null(),
            collection: BufferCollectionFUCHSIA::default(),
            index: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferCollectionConstraintsInfoFUCHSIA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferCollectionConstraintsInfoFUCHSIA {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub min_buffer_count: u32,
    pub max_buffer_count: u32,
    pub min_buffer_count_for_camping: u32,
    pub min_buffer_count_for_dedicated_slack: u32,
    pub min_buffer_count_for_shared_slack: u32,
}

impl Default for BufferCollectionConstraintsInfoFUCHSIA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA,
            next: ptr::null(),
            min_buffer_count: u32::default(),
            max_buffer_count: u32::default(),
            min_buffer_count_for_camping: u32::default(),
            min_buffer_count_for_dedicated_slack: u32::default(),
            min_buffer_count_for_shared_slack: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferCollectionCreateInfoFUCHSIA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferCollectionCreateInfoFUCHSIA {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub collection_token: zx_handle_t,
}

impl Default for BufferCollectionCreateInfoFUCHSIA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA,
            next: ptr::null(),
            collection_token: zx_handle_t::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferCollectionImageCreateInfoFUCHSIA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferCollectionImageCreateInfoFUCHSIA {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub collection: BufferCollectionFUCHSIA,
    pub index: u32,
}

impl Default for BufferCollectionImageCreateInfoFUCHSIA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA,
            next: ptr::null(),
            collection: BufferCollectionFUCHSIA::default(),
            index: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferCollectionPropertiesFUCHSIA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferCollectionPropertiesFUCHSIA {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub memory_type_bits: u32,
    pub buffer_count: u32,
    pub create_info_index: u32,
    pub sysmem_pixel_format: u64,
    pub format_features: FormatFeatureFlags,
    pub sysmem_color_space_index: SysmemColorSpaceFUCHSIA,
    pub sampler_ycbcr_conversion_components: ComponentMapping,
    pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
    pub suggested_ycbcr_range: SamplerYcbcrRange,
    pub suggested_x_chroma_offset: ChromaLocation,
    pub suggested_y_chroma_offset: ChromaLocation,
}

impl Default for BufferCollectionPropertiesFUCHSIA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_COLLECTION_PROPERTIES_FUCHSIA,
            next: ptr::null_mut(),
            memory_type_bits: u32::default(),
            buffer_count: u32::default(),
            create_info_index: u32::default(),
            sysmem_pixel_format: u64::default(),
            format_features: FormatFeatureFlags::default(),
            sysmem_color_space_index: SysmemColorSpaceFUCHSIA::default(),
            sampler_ycbcr_conversion_components: ComponentMapping::default(),
            suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
            suggested_ycbcr_range: SamplerYcbcrRange::default(),
            suggested_x_chroma_offset: ChromaLocation::default(),
            suggested_y_chroma_offset: ChromaLocation::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferConstraintsInfoFUCHSIA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferConstraintsInfoFUCHSIA {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub create_info: BufferCreateInfo,
    pub required_format_features: FormatFeatureFlags,
    pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
}

impl Default for BufferConstraintsInfoFUCHSIA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_CONSTRAINTS_INFO_FUCHSIA,
            next: ptr::null(),
            create_info: BufferCreateInfo::default(),
            required_format_features: FormatFeatureFlags::default(),
            buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferCopy.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct BufferCopy {
    pub src_offset: DeviceSize,
    pub dst_offset: DeviceSize,
    pub size: DeviceSize,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferCopy2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferCopy2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_offset: DeviceSize,
    pub dst_offset: DeviceSize,
    pub size: DeviceSize,
}

impl Default for BufferCopy2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_COPY_2,
            next: ptr::null(),
            src_offset: DeviceSize::default(),
            dst_offset: DeviceSize::default(),
            size: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: BufferCreateFlags,
    pub size: DeviceSize,
    pub usage: BufferUsageFlags,
    pub sharing_mode: SharingMode,
    pub queue_family_index_count: u32,
    pub queue_family_indices: *const u32,
}

impl Default for BufferCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_CREATE_INFO,
            next: ptr::null(),
            flags: BufferCreateFlags::default(),
            size: DeviceSize::default(),
            usage: BufferUsageFlags::default(),
            sharing_mode: SharingMode::default(),
            queue_family_index_count: u32::default(),
            queue_family_indices: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferDeviceAddressCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferDeviceAddressCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub device_address: DeviceAddress,
}

impl Default for BufferDeviceAddressCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT,
            next: ptr::null(),
            device_address: DeviceAddress::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferDeviceAddressInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferDeviceAddressInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub buffer: Buffer,
}

impl Default for BufferDeviceAddressInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_DEVICE_ADDRESS_INFO,
            next: ptr::null(),
            buffer: Buffer::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferImageCopy.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct BufferImageCopy {
    pub buffer_offset: DeviceSize,
    pub buffer_row_length: u32,
    pub buffer_image_height: u32,
    pub image_subresource: ImageSubresourceLayers,
    pub image_offset: Offset3D,
    pub image_extent: Extent3D,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferImageCopy2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferImageCopy2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub buffer_offset: DeviceSize,
    pub buffer_row_length: u32,
    pub buffer_image_height: u32,
    pub image_subresource: ImageSubresourceLayers,
    pub image_offset: Offset3D,
    pub image_extent: Extent3D,
}

impl Default for BufferImageCopy2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_IMAGE_COPY_2,
            next: ptr::null(),
            buffer_offset: DeviceSize::default(),
            buffer_row_length: u32::default(),
            buffer_image_height: u32::default(),
            image_subresource: ImageSubresourceLayers::default(),
            image_offset: Offset3D::default(),
            image_extent: Extent3D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferMemoryBarrier.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferMemoryBarrier {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_access_mask: AccessFlags,
    pub dst_access_mask: AccessFlags,
    pub src_queue_family_index: u32,
    pub dst_queue_family_index: u32,
    pub buffer: Buffer,
    pub offset: DeviceSize,
    pub size: DeviceSize,
}

impl Default for BufferMemoryBarrier {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_MEMORY_BARRIER,
            next: ptr::null(),
            src_access_mask: AccessFlags::default(),
            dst_access_mask: AccessFlags::default(),
            src_queue_family_index: u32::default(),
            dst_queue_family_index: u32::default(),
            buffer: Buffer::default(),
            offset: DeviceSize::default(),
            size: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferMemoryBarrier2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferMemoryBarrier2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_stage_mask: PipelineStageFlags2,
    pub src_access_mask: AccessFlags2,
    pub dst_stage_mask: PipelineStageFlags2,
    pub dst_access_mask: AccessFlags2,
    pub src_queue_family_index: u32,
    pub dst_queue_family_index: u32,
    pub buffer: Buffer,
    pub offset: DeviceSize,
    pub size: DeviceSize,
}

impl Default for BufferMemoryBarrier2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_MEMORY_BARRIER_2,
            next: ptr::null(),
            src_stage_mask: PipelineStageFlags2::default(),
            src_access_mask: AccessFlags2::default(),
            dst_stage_mask: PipelineStageFlags2::default(),
            dst_access_mask: AccessFlags2::default(),
            src_queue_family_index: u32::default(),
            dst_queue_family_index: u32::default(),
            buffer: Buffer::default(),
            offset: DeviceSize::default(),
            size: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferMemoryRequirementsInfo2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferMemoryRequirementsInfo2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub buffer: Buffer,
}

impl Default for BufferMemoryRequirementsInfo2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_MEMORY_REQUIREMENTS_INFO_2,
            next: ptr::null(),
            buffer: Buffer::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferOpaqueCaptureAddressCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferOpaqueCaptureAddressCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub opaque_capture_address: u64,
}

impl Default for BufferOpaqueCaptureAddressCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,
            next: ptr::null(),
            opaque_capture_address: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferUsageFlags2CreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferUsageFlags2CreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub usage: BufferUsageFlags2,
}

impl Default for BufferUsageFlags2CreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_USAGE_FLAGS_2_CREATE_INFO,
            next: ptr::null(),
            usage: BufferUsageFlags2::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferViewCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BufferViewCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: BufferViewCreateFlags,
    pub buffer: Buffer,
    pub format: Format,
    pub offset: DeviceSize,
    pub range: DeviceSize,
}

impl Default for BufferViewCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUFFER_VIEW_CREATE_INFO,
            next: ptr::null(),
            flags: BufferViewCreateFlags::default(),
            buffer: Buffer::default(),
            format: Format::default(),
            offset: DeviceSize::default(),
            range: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBuildPartitionedAccelerationStructureIndirectCommandNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct BuildPartitionedAccelerationStructureIndirectCommandNV {
    pub op_type: PartitionedAccelerationStructureOpTypeNV,
    pub arg_count: u32,
    pub arg_data: StridedDeviceAddressNV,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBuildPartitionedAccelerationStructureInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct BuildPartitionedAccelerationStructureInfoNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub input: PartitionedAccelerationStructureInstancesInputNV,
    pub src_acceleration_structure_data: DeviceAddress,
    pub dst_acceleration_structure_data: DeviceAddress,
    pub scratch_data: DeviceAddress,
    pub src_infos: DeviceAddress,
    pub src_infos_count: DeviceAddress,
}

impl Default for BuildPartitionedAccelerationStructureInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV,
            next: ptr::null_mut(),
            input: PartitionedAccelerationStructureInstancesInputNV::default(),
            src_acceleration_structure_data: DeviceAddress::default(),
            dst_acceleration_structure_data: DeviceAddress::default(),
            scratch_data: DeviceAddress::default(),
            src_infos: DeviceAddress::default(),
            src_infos_count: DeviceAddress::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCalibratedTimestampInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CalibratedTimestampInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub time_domain: TimeDomainKHR,
}

impl Default for CalibratedTimestampInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CALIBRATED_TIMESTAMP_INFO_KHR,
            next: ptr::null(),
            time_domain: TimeDomainKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCheckpointData2NV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CheckpointData2NV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub stage: PipelineStageFlags2,
    pub checkpoint_marker: *mut c_void,
}

impl Default for CheckpointData2NV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CHECKPOINT_DATA_2_NV,
            next: ptr::null_mut(),
            stage: PipelineStageFlags2::default(),
            checkpoint_marker: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCheckpointDataNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CheckpointDataNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub stage: PipelineStageFlags,
    pub checkpoint_marker: *mut c_void,
}

impl Default for CheckpointDataNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CHECKPOINT_DATA_NV,
            next: ptr::null_mut(),
            stage: PipelineStageFlags::default(),
            checkpoint_marker: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkClearAttachment.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
pub struct ClearAttachment {
    pub aspect_mask: ImageAspectFlags,
    pub color_attachment: u32,
    pub clear_value: ClearValue,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkClearDepthStencilValue.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq)]
pub struct ClearDepthStencilValue {
    pub depth: f32,
    pub stencil: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkClearRect.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ClearRect {
    pub rect: Rect2D,
    pub base_array_layer: u32,
    pub layer_count: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ClusterAccelerationStructureBuildClustersBottomLevelInfoNV {
    pub cluster_references_count: u32,
    pub cluster_references_stride: u32,
    pub cluster_references: DeviceAddress,
}

bitfields32! {
    struct ClusterAccelerationStructureBuildTriangleClusterInfoNVBitfields0 {
        (triangle_count, with_triangle_count)[0 .. 9],
        (vertex_count, with_vertex_count)[9 .. 18],
        (position_truncate_bit_count, with_position_truncate_bit_count)[18 .. 24],
        (index_type, with_index_type)[24 .. 28],
        (opacity_micromap_index_type, with_opacity_micromap_index_type)[28 .. 32],
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkClusterAccelerationStructureBuildTriangleClusterInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ClusterAccelerationStructureBuildTriangleClusterInfoNV {
    pub cluster_id: u32,
    pub cluster_flags: ClusterAccelerationStructureClusterFlagsNV,
    pub base_geometry_index_and_geometry_flags:
        ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV,
    pub index_buffer_stride: u16,
    pub vertex_buffer_stride: u16,
    pub geometry_index_and_flags_buffer_stride: u16,
    pub opacity_micromap_index_buffer_stride: u16,
    pub index_buffer: DeviceAddress,
    pub vertex_buffer: DeviceAddress,
    pub geometry_index_and_flags_buffer: DeviceAddress,
    pub opacity_micromap_array: DeviceAddress,
    pub opacity_micromap_index_buffer: DeviceAddress,
    pub bitfields0: ClusterAccelerationStructureBuildTriangleClusterInfoNVBitfields0,
}

bitfields32! {
    struct ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNVBitfields0 {
        (triangle_count, with_triangle_count)[0 .. 9],
        (vertex_count, with_vertex_count)[9 .. 18],
        (position_truncate_bit_count, with_position_truncate_bit_count)[18 .. 24],
        (index_type, with_index_type)[24 .. 28],
        (opacity_micromap_index_type, with_opacity_micromap_index_type)[28 .. 32],
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV {
    pub cluster_id: u32,
    pub cluster_flags: ClusterAccelerationStructureClusterFlagsNV,
    pub base_geometry_index_and_geometry_flags:
        ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV,
    pub index_buffer_stride: u16,
    pub vertex_buffer_stride: u16,
    pub geometry_index_and_flags_buffer_stride: u16,
    pub opacity_micromap_index_buffer_stride: u16,
    pub index_buffer: DeviceAddress,
    pub vertex_buffer: DeviceAddress,
    pub geometry_index_and_flags_buffer: DeviceAddress,
    pub opacity_micromap_array: DeviceAddress,
    pub opacity_micromap_index_buffer: DeviceAddress,
    pub instantiation_bounding_box_limit: DeviceAddress,
    pub bitfields0: ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNVBitfields0,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkClusterAccelerationStructureClustersBottomLevelInputNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ClusterAccelerationStructureClustersBottomLevelInputNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_total_cluster_count: u32,
    pub max_cluster_count_per_acceleration_structure: u32,
}

impl Default for ClusterAccelerationStructureClustersBottomLevelInputNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV,
            next: ptr::null_mut(),
            max_total_cluster_count: u32::default(),
            max_cluster_count_per_acceleration_structure: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkClusterAccelerationStructureCommandsInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ClusterAccelerationStructureCommandsInfoNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub input: ClusterAccelerationStructureInputInfoNV,
    pub dst_implicit_data: DeviceAddress,
    pub scratch_data: DeviceAddress,
    pub dst_addresses_array: StridedDeviceAddressRegionKHR,
    pub dst_sizes_array: StridedDeviceAddressRegionKHR,
    pub src_infos_array: StridedDeviceAddressRegionKHR,
    pub src_infos_count: DeviceAddress,
    pub address_resolution_flags: ClusterAccelerationStructureAddressResolutionFlagsNV,
}

impl Default for ClusterAccelerationStructureCommandsInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV,
            next: ptr::null_mut(),
            input: ClusterAccelerationStructureInputInfoNV::default(),
            dst_implicit_data: DeviceAddress::default(),
            scratch_data: DeviceAddress::default(),
            dst_addresses_array: StridedDeviceAddressRegionKHR::default(),
            dst_sizes_array: StridedDeviceAddressRegionKHR::default(),
            src_infos_array: StridedDeviceAddressRegionKHR::default(),
            src_infos_count: DeviceAddress::default(),
            address_resolution_flags: ClusterAccelerationStructureAddressResolutionFlagsNV::default(
            ),
        }
    }
}

bitfields32! {
    struct ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNVBitfields0 {
        (geometry_index, with_geometry_index)[0 .. 24],
        (reserved, with_reserved)[24 .. 29],
        (geometry_flags, with_geometry_flags)[29 .. 32],
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV {
    pub bitfields0: ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNVBitfields0,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkClusterAccelerationStructureInputInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ClusterAccelerationStructureInputInfoNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_acceleration_structure_count: u32,
    pub flags: BuildAccelerationStructureFlagsKHR,
    pub op_type: ClusterAccelerationStructureOpTypeNV,
    pub op_mode: ClusterAccelerationStructureOpModeNV,
    pub op_input: ClusterAccelerationStructureOpInputNV,
}

impl Default for ClusterAccelerationStructureInputInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV,
            next: ptr::null_mut(),
            max_acceleration_structure_count: u32::default(),
            flags: BuildAccelerationStructureFlagsKHR::default(),
            op_type: ClusterAccelerationStructureOpTypeNV::default(),
            op_mode: ClusterAccelerationStructureOpModeNV::default(),
            op_input: ClusterAccelerationStructureOpInputNV::default(),
        }
    }
}

bitfields32! {
    struct ClusterAccelerationStructureInstantiateClusterInfoNVBitfields0 {
        (geometry_index_offset, with_geometry_index_offset)[0 .. 24],
        (reserved, with_reserved)[24 .. 32],
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkClusterAccelerationStructureInstantiateClusterInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ClusterAccelerationStructureInstantiateClusterInfoNV {
    pub cluster_id_offset: u32,
    pub cluster_template_address: DeviceAddress,
    pub vertex_buffer: StridedDeviceAddressNV,
    pub bitfields0: ClusterAccelerationStructureInstantiateClusterInfoNVBitfields0,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkClusterAccelerationStructureMoveObjectsInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ClusterAccelerationStructureMoveObjectsInfoNV {
    pub src_acceleration_structure: DeviceAddress,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkClusterAccelerationStructureMoveObjectsInputNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ClusterAccelerationStructureMoveObjectsInputNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub type_: ClusterAccelerationStructureTypeNV,
    pub no_move_overlap: Bool32,
    pub max_moved_bytes: DeviceSize,
}

impl Default for ClusterAccelerationStructureMoveObjectsInputNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV,
            next: ptr::null_mut(),
            type_: ClusterAccelerationStructureTypeNV::default(),
            no_move_overlap: Bool32::default(),
            max_moved_bytes: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkClusterAccelerationStructureTriangleClusterInputNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ClusterAccelerationStructureTriangleClusterInputNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub vertex_format: Format,
    pub max_geometry_index_value: u32,
    pub max_cluster_unique_geometry_count: u32,
    pub max_cluster_triangle_count: u32,
    pub max_cluster_vertex_count: u32,
    pub max_total_triangle_count: u32,
    pub max_total_vertex_count: u32,
    pub min_position_truncate_bit_count: u32,
}

impl Default for ClusterAccelerationStructureTriangleClusterInputNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV,
            next: ptr::null_mut(),
            vertex_format: Format::default(),
            max_geometry_index_value: u32::default(),
            max_cluster_unique_geometry_count: u32::default(),
            max_cluster_triangle_count: u32::default(),
            max_cluster_vertex_count: u32::default(),
            max_total_triangle_count: u32::default(),
            max_total_vertex_count: u32::default(),
            min_position_truncate_bit_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCoarseSampleLocationNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct CoarseSampleLocationNV {
    pub pixel_x: u32,
    pub pixel_y: u32,
    pub sample: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCoarseSampleOrderCustomNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CoarseSampleOrderCustomNV {
    pub shading_rate: ShadingRatePaletteEntryNV,
    pub sample_count: u32,
    pub sample_location_count: u32,
    pub sample_locations: *const CoarseSampleLocationNV,
}

impl Default for CoarseSampleOrderCustomNV {
    #[inline]
    fn default() -> Self {
        Self {
            shading_rate: ShadingRatePaletteEntryNV::default(),
            sample_count: u32::default(),
            sample_location_count: u32::default(),
            sample_locations: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkColorBlendAdvancedEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ColorBlendAdvancedEXT {
    pub advanced_blend_op: BlendOp,
    pub src_premultiplied: Bool32,
    pub dst_premultiplied: Bool32,
    pub blend_overlap: BlendOverlapEXT,
    pub clamp_results: Bool32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkColorBlendEquationEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ColorBlendEquationEXT {
    pub src_color_blend_factor: BlendFactor,
    pub dst_color_blend_factor: BlendFactor,
    pub color_blend_op: BlendOp,
    pub src_alpha_blend_factor: BlendFactor,
    pub dst_alpha_blend_factor: BlendFactor,
    pub alpha_blend_op: BlendOp,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCommandBufferAllocateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CommandBufferAllocateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub command_pool: CommandPool,
    pub level: CommandBufferLevel,
    pub command_buffer_count: u32,
}

impl Default for CommandBufferAllocateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COMMAND_BUFFER_ALLOCATE_INFO,
            next: ptr::null(),
            command_pool: CommandPool::default(),
            level: CommandBufferLevel::default(),
            command_buffer_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCommandBufferBeginInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CommandBufferBeginInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: CommandBufferUsageFlags,
    pub inheritance_info: *const CommandBufferInheritanceInfo,
}

impl Default for CommandBufferBeginInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COMMAND_BUFFER_BEGIN_INFO,
            next: ptr::null(),
            flags: CommandBufferUsageFlags::default(),
            inheritance_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCommandBufferInheritanceConditionalRenderingInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CommandBufferInheritanceConditionalRenderingInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub conditional_rendering_enable: Bool32,
}

impl Default for CommandBufferInheritanceConditionalRenderingInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT,
            next: ptr::null(),
            conditional_rendering_enable: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCommandBufferInheritanceInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CommandBufferInheritanceInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub render_pass: RenderPass,
    pub subpass: u32,
    pub framebuffer: Framebuffer,
    pub occlusion_query_enable: Bool32,
    pub query_flags: QueryControlFlags,
    pub pipeline_statistics: QueryPipelineStatisticFlags,
}

impl Default for CommandBufferInheritanceInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_INFO,
            next: ptr::null(),
            render_pass: RenderPass::default(),
            subpass: u32::default(),
            framebuffer: Framebuffer::default(),
            occlusion_query_enable: Bool32::default(),
            query_flags: QueryControlFlags::default(),
            pipeline_statistics: QueryPipelineStatisticFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCommandBufferInheritanceRenderPassTransformInfoQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CommandBufferInheritanceRenderPassTransformInfoQCOM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub transform: SurfaceTransformFlagsKHR,
    pub render_area: Rect2D,
}

impl Default for CommandBufferInheritanceRenderPassTransformInfoQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM,
            next: ptr::null_mut(),
            transform: SurfaceTransformFlagsKHR::default(),
            render_area: Rect2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCommandBufferInheritanceRenderingInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CommandBufferInheritanceRenderingInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: RenderingFlags,
    pub view_mask: u32,
    pub color_attachment_count: u32,
    pub color_attachment_formats: *const Format,
    pub depth_attachment_format: Format,
    pub stencil_attachment_format: Format,
    pub rasterization_samples: SampleCountFlags,
}

impl Default for CommandBufferInheritanceRenderingInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO,
            next: ptr::null(),
            flags: RenderingFlags::default(),
            view_mask: u32::default(),
            color_attachment_count: u32::default(),
            color_attachment_formats: ptr::null(),
            depth_attachment_format: Format::default(),
            stencil_attachment_format: Format::default(),
            rasterization_samples: SampleCountFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCommandBufferInheritanceViewportScissorInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CommandBufferInheritanceViewportScissorInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub viewport_scissor_2d: Bool32,
    pub viewport_depth_count: u32,
    pub viewport_depths: *const Viewport,
}

impl Default for CommandBufferInheritanceViewportScissorInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV,
            next: ptr::null(),
            viewport_scissor_2d: Bool32::default(),
            viewport_depth_count: u32::default(),
            viewport_depths: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCommandBufferSubmitInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CommandBufferSubmitInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub command_buffer: CommandBuffer,
    pub device_mask: u32,
}

impl Default for CommandBufferSubmitInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COMMAND_BUFFER_SUBMIT_INFO,
            next: ptr::null(),
            command_buffer: CommandBuffer::default(),
            device_mask: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCommandPoolCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CommandPoolCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: CommandPoolCreateFlags,
    pub queue_family_index: u32,
}

impl Default for CommandPoolCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COMMAND_POOL_CREATE_INFO,
            next: ptr::null(),
            flags: CommandPoolCreateFlags::default(),
            queue_family_index: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkComponentMapping.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ComponentMapping {
    pub r: ComponentSwizzle,
    pub g: ComponentSwizzle,
    pub b: ComponentSwizzle,
    pub a: ComponentSwizzle,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkComputePipelineCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ComputePipelineCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineCreateFlags,
    pub stage: PipelineShaderStageCreateInfo,
    pub layout: PipelineLayout,
    pub base_pipeline_handle: Pipeline,
    pub base_pipeline_index: i32,
}

impl Default for ComputePipelineCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COMPUTE_PIPELINE_CREATE_INFO,
            next: ptr::null(),
            flags: PipelineCreateFlags::default(),
            stage: PipelineShaderStageCreateInfo::default(),
            layout: PipelineLayout::default(),
            base_pipeline_handle: Pipeline::default(),
            base_pipeline_index: i32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkComputePipelineIndirectBufferInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ComputePipelineIndirectBufferInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub device_address: DeviceAddress,
    pub size: DeviceSize,
    pub pipeline_device_address_capture_replay: DeviceAddress,
}

impl Default for ComputePipelineIndirectBufferInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV,
            next: ptr::null(),
            device_address: DeviceAddress::default(),
            size: DeviceSize::default(),
            pipeline_device_address_capture_replay: DeviceAddress::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkConditionalRenderingBeginInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ConditionalRenderingBeginInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub buffer: Buffer,
    pub offset: DeviceSize,
    pub flags: ConditionalRenderingFlagsEXT,
}

impl Default for ConditionalRenderingBeginInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CONDITIONAL_RENDERING_BEGIN_INFO_EXT,
            next: ptr::null(),
            buffer: Buffer::default(),
            offset: DeviceSize::default(),
            flags: ConditionalRenderingFlagsEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkConformanceVersion.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ConformanceVersion {
    pub major: u8,
    pub minor: u8,
    pub subminor: u8,
    pub patch: u8,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkConvertCooperativeVectorMatrixInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ConvertCooperativeVectorMatrixInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_size: usize,
    pub src_data: DeviceOrHostAddressConstKHR,
    pub dst_size: *mut usize,
    pub dst_data: DeviceOrHostAddressKHR,
    pub src_component_type: ComponentTypeKHR,
    pub dst_component_type: ComponentTypeKHR,
    pub num_rows: u32,
    pub num_columns: u32,
    pub src_layout: CooperativeVectorMatrixLayoutNV,
    pub src_stride: usize,
    pub dst_layout: CooperativeVectorMatrixLayoutNV,
    pub dst_stride: usize,
}

impl Default for ConvertCooperativeVectorMatrixInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV,
            next: ptr::null(),
            src_size: usize::default(),
            src_data: DeviceOrHostAddressConstKHR::default(),
            dst_size: ptr::null_mut(),
            dst_data: DeviceOrHostAddressKHR::default(),
            src_component_type: ComponentTypeKHR::default(),
            dst_component_type: ComponentTypeKHR::default(),
            num_rows: u32::default(),
            num_columns: u32::default(),
            src_layout: CooperativeVectorMatrixLayoutNV::default(),
            src_stride: usize::default(),
            dst_layout: CooperativeVectorMatrixLayoutNV::default(),
            dst_stride: usize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCooperativeMatrixFlexibleDimensionsPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CooperativeMatrixFlexibleDimensionsPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub m_granularity: u32,
    pub n_granularity: u32,
    pub k_granularity: u32,
    pub a_type: ComponentTypeKHR,
    pub b_type: ComponentTypeKHR,
    pub c_type: ComponentTypeKHR,
    pub result_type: ComponentTypeKHR,
    pub saturating_accumulation: Bool32,
    pub scope: ScopeKHR,
    pub workgroup_invocations: u32,
}

impl Default for CooperativeMatrixFlexibleDimensionsPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV,
            next: ptr::null_mut(),
            m_granularity: u32::default(),
            n_granularity: u32::default(),
            k_granularity: u32::default(),
            a_type: ComponentTypeKHR::default(),
            b_type: ComponentTypeKHR::default(),
            c_type: ComponentTypeKHR::default(),
            result_type: ComponentTypeKHR::default(),
            saturating_accumulation: Bool32::default(),
            scope: ScopeKHR::default(),
            workgroup_invocations: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCooperativeMatrixPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CooperativeMatrixPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub m_size: u32,
    pub n_size: u32,
    pub k_size: u32,
    pub a_type: ComponentTypeKHR,
    pub b_type: ComponentTypeKHR,
    pub c_type: ComponentTypeKHR,
    pub result_type: ComponentTypeKHR,
    pub saturating_accumulation: Bool32,
    pub scope: ScopeKHR,
}

impl Default for CooperativeMatrixPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COOPERATIVE_MATRIX_PROPERTIES_KHR,
            next: ptr::null_mut(),
            m_size: u32::default(),
            n_size: u32::default(),
            k_size: u32::default(),
            a_type: ComponentTypeKHR::default(),
            b_type: ComponentTypeKHR::default(),
            c_type: ComponentTypeKHR::default(),
            result_type: ComponentTypeKHR::default(),
            saturating_accumulation: Bool32::default(),
            scope: ScopeKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCooperativeMatrixPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CooperativeMatrixPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub m_size: u32,
    pub n_size: u32,
    pub k_size: u32,
    pub a_type: ComponentTypeNV,
    pub b_type: ComponentTypeNV,
    pub c_type: ComponentTypeNV,
    pub d_type: ComponentTypeNV,
    pub scope: ScopeNV,
}

impl Default for CooperativeMatrixPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COOPERATIVE_MATRIX_PROPERTIES_NV,
            next: ptr::null_mut(),
            m_size: u32::default(),
            n_size: u32::default(),
            k_size: u32::default(),
            a_type: ComponentTypeNV::default(),
            b_type: ComponentTypeNV::default(),
            c_type: ComponentTypeNV::default(),
            d_type: ComponentTypeNV::default(),
            scope: ScopeNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCooperativeVectorPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CooperativeVectorPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub input_type: ComponentTypeKHR,
    pub input_interpretation: ComponentTypeKHR,
    pub matrix_interpretation: ComponentTypeKHR,
    pub bias_interpretation: ComponentTypeKHR,
    pub result_type: ComponentTypeKHR,
    pub transpose: Bool32,
}

impl Default for CooperativeVectorPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COOPERATIVE_VECTOR_PROPERTIES_NV,
            next: ptr::null_mut(),
            input_type: ComponentTypeKHR::default(),
            input_interpretation: ComponentTypeKHR::default(),
            matrix_interpretation: ComponentTypeKHR::default(),
            bias_interpretation: ComponentTypeKHR::default(),
            result_type: ComponentTypeKHR::default(),
            transpose: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyAccelerationStructureInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CopyAccelerationStructureInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src: AccelerationStructureKHR,
    pub dst: AccelerationStructureKHR,
    pub mode: CopyAccelerationStructureModeKHR,
}

impl Default for CopyAccelerationStructureInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COPY_ACCELERATION_STRUCTURE_INFO_KHR,
            next: ptr::null(),
            src: AccelerationStructureKHR::default(),
            dst: AccelerationStructureKHR::default(),
            mode: CopyAccelerationStructureModeKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyAccelerationStructureToMemoryInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyAccelerationStructureToMemoryInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src: AccelerationStructureKHR,
    pub dst: DeviceOrHostAddressKHR,
    pub mode: CopyAccelerationStructureModeKHR,
}

impl Default for CopyAccelerationStructureToMemoryInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR,
            next: ptr::null(),
            src: AccelerationStructureKHR::default(),
            dst: DeviceOrHostAddressKHR::default(),
            mode: CopyAccelerationStructureModeKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyBufferInfo2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CopyBufferInfo2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_buffer: Buffer,
    pub dst_buffer: Buffer,
    pub region_count: u32,
    pub regions: *const BufferCopy2,
}

impl Default for CopyBufferInfo2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COPY_BUFFER_INFO_2,
            next: ptr::null(),
            src_buffer: Buffer::default(),
            dst_buffer: Buffer::default(),
            region_count: u32::default(),
            regions: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyBufferToImageInfo2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CopyBufferToImageInfo2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_buffer: Buffer,
    pub dst_image: Image,
    pub dst_image_layout: ImageLayout,
    pub region_count: u32,
    pub regions: *const BufferImageCopy2,
}

impl Default for CopyBufferToImageInfo2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COPY_BUFFER_TO_IMAGE_INFO_2,
            next: ptr::null(),
            src_buffer: Buffer::default(),
            dst_image: Image::default(),
            dst_image_layout: ImageLayout::default(),
            region_count: u32::default(),
            regions: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyCommandTransformInfoQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CopyCommandTransformInfoQCOM {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub transform: SurfaceTransformFlagsKHR,
}

impl Default for CopyCommandTransformInfoQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COPY_COMMAND_TRANSFORM_INFO_QCOM,
            next: ptr::null(),
            transform: SurfaceTransformFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyDescriptorSet.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CopyDescriptorSet {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_set: DescriptorSet,
    pub src_binding: u32,
    pub src_array_element: u32,
    pub dst_set: DescriptorSet,
    pub dst_binding: u32,
    pub dst_array_element: u32,
    pub descriptor_count: u32,
}

impl Default for CopyDescriptorSet {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COPY_DESCRIPTOR_SET,
            next: ptr::null(),
            src_set: DescriptorSet::default(),
            src_binding: u32::default(),
            src_array_element: u32::default(),
            dst_set: DescriptorSet::default(),
            dst_binding: u32::default(),
            dst_array_element: u32::default(),
            descriptor_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyImageInfo2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CopyImageInfo2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_image: Image,
    pub src_image_layout: ImageLayout,
    pub dst_image: Image,
    pub dst_image_layout: ImageLayout,
    pub region_count: u32,
    pub regions: *const ImageCopy2,
}

impl Default for CopyImageInfo2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COPY_IMAGE_INFO_2,
            next: ptr::null(),
            src_image: Image::default(),
            src_image_layout: ImageLayout::default(),
            dst_image: Image::default(),
            dst_image_layout: ImageLayout::default(),
            region_count: u32::default(),
            regions: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyImageToBufferInfo2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CopyImageToBufferInfo2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_image: Image,
    pub src_image_layout: ImageLayout,
    pub dst_buffer: Buffer,
    pub region_count: u32,
    pub regions: *const BufferImageCopy2,
}

impl Default for CopyImageToBufferInfo2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COPY_IMAGE_TO_BUFFER_INFO_2,
            next: ptr::null(),
            src_image: Image::default(),
            src_image_layout: ImageLayout::default(),
            dst_buffer: Buffer::default(),
            region_count: u32::default(),
            regions: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyImageToImageInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CopyImageToImageInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: HostImageCopyFlags,
    pub src_image: Image,
    pub src_image_layout: ImageLayout,
    pub dst_image: Image,
    pub dst_image_layout: ImageLayout,
    pub region_count: u32,
    pub regions: *const ImageCopy2,
}

impl Default for CopyImageToImageInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COPY_IMAGE_TO_IMAGE_INFO,
            next: ptr::null(),
            flags: HostImageCopyFlags::default(),
            src_image: Image::default(),
            src_image_layout: ImageLayout::default(),
            dst_image: Image::default(),
            dst_image_layout: ImageLayout::default(),
            region_count: u32::default(),
            regions: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyImageToMemoryInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CopyImageToMemoryInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: HostImageCopyFlags,
    pub src_image: Image,
    pub src_image_layout: ImageLayout,
    pub region_count: u32,
    pub regions: *const ImageToMemoryCopy,
}

impl Default for CopyImageToMemoryInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COPY_IMAGE_TO_MEMORY_INFO,
            next: ptr::null(),
            flags: HostImageCopyFlags::default(),
            src_image: Image::default(),
            src_image_layout: ImageLayout::default(),
            region_count: u32::default(),
            regions: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyMemoryIndirectCommandNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct CopyMemoryIndirectCommandNV {
    pub src_address: DeviceAddress,
    pub dst_address: DeviceAddress,
    pub size: DeviceSize,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyMemoryToAccelerationStructureInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyMemoryToAccelerationStructureInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src: DeviceOrHostAddressConstKHR,
    pub dst: AccelerationStructureKHR,
    pub mode: CopyAccelerationStructureModeKHR,
}

impl Default for CopyMemoryToAccelerationStructureInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR,
            next: ptr::null(),
            src: DeviceOrHostAddressConstKHR::default(),
            dst: AccelerationStructureKHR::default(),
            mode: CopyAccelerationStructureModeKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyMemoryToImageIndirectCommandNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct CopyMemoryToImageIndirectCommandNV {
    pub src_address: DeviceAddress,
    pub buffer_row_length: u32,
    pub buffer_image_height: u32,
    pub image_subresource: ImageSubresourceLayers,
    pub image_offset: Offset3D,
    pub image_extent: Extent3D,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyMemoryToImageInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CopyMemoryToImageInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: HostImageCopyFlags,
    pub dst_image: Image,
    pub dst_image_layout: ImageLayout,
    pub region_count: u32,
    pub regions: *const MemoryToImageCopy,
}

impl Default for CopyMemoryToImageInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COPY_MEMORY_TO_IMAGE_INFO,
            next: ptr::null(),
            flags: HostImageCopyFlags::default(),
            dst_image: Image::default(),
            dst_image_layout: ImageLayout::default(),
            region_count: u32::default(),
            regions: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyMemoryToMicromapInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyMemoryToMicromapInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src: DeviceOrHostAddressConstKHR,
    pub dst: MicromapEXT,
    pub mode: CopyMicromapModeEXT,
}

impl Default for CopyMemoryToMicromapInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COPY_MEMORY_TO_MICROMAP_INFO_EXT,
            next: ptr::null(),
            src: DeviceOrHostAddressConstKHR::default(),
            dst: MicromapEXT::default(),
            mode: CopyMicromapModeEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyMicromapInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CopyMicromapInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src: MicromapEXT,
    pub dst: MicromapEXT,
    pub mode: CopyMicromapModeEXT,
}

impl Default for CopyMicromapInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COPY_MICROMAP_INFO_EXT,
            next: ptr::null(),
            src: MicromapEXT::default(),
            dst: MicromapEXT::default(),
            mode: CopyMicromapModeEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyMicromapToMemoryInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyMicromapToMemoryInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src: MicromapEXT,
    pub dst: DeviceOrHostAddressKHR,
    pub mode: CopyMicromapModeEXT,
}

impl Default for CopyMicromapToMemoryInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::COPY_MICROMAP_TO_MEMORY_INFO_EXT,
            next: ptr::null(),
            src: MicromapEXT::default(),
            dst: DeviceOrHostAddressKHR::default(),
            mode: CopyMicromapModeEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCuFunctionCreateInfoNVX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CuFunctionCreateInfoNVX {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub module: CuModuleNVX,
    pub name: *const c_char,
}

impl Default for CuFunctionCreateInfoNVX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CU_FUNCTION_CREATE_INFO_NVX,
            next: ptr::null(),
            module: CuModuleNVX::default(),
            name: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCuLaunchInfoNVX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CuLaunchInfoNVX {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub function: CuFunctionNVX,
    pub grid_dim_x: u32,
    pub grid_dim_y: u32,
    pub grid_dim_z: u32,
    pub block_dim_x: u32,
    pub block_dim_y: u32,
    pub block_dim_z: u32,
    pub shared_mem_bytes: u32,
    pub param_count: usize,
    pub params: *const c_void,
    pub extra_count: usize,
    pub extras: *const c_void,
}

impl Default for CuLaunchInfoNVX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CU_LAUNCH_INFO_NVX,
            next: ptr::null(),
            function: CuFunctionNVX::default(),
            grid_dim_x: u32::default(),
            grid_dim_y: u32::default(),
            grid_dim_z: u32::default(),
            block_dim_x: u32::default(),
            block_dim_y: u32::default(),
            block_dim_z: u32::default(),
            shared_mem_bytes: u32::default(),
            param_count: usize::default(),
            params: ptr::null(),
            extra_count: usize::default(),
            extras: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCuModuleCreateInfoNVX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CuModuleCreateInfoNVX {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub data_size: usize,
    pub data: *const c_void,
}

impl Default for CuModuleCreateInfoNVX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CU_MODULE_CREATE_INFO_NVX,
            next: ptr::null(),
            data_size: usize::default(),
            data: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCuModuleTexturingModeCreateInfoNVX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CuModuleTexturingModeCreateInfoNVX {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub use64bit_texturing: Bool32,
}

impl Default for CuModuleTexturingModeCreateInfoNVX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX,
            next: ptr::null(),
            use64bit_texturing: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCudaFunctionCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CudaFunctionCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub module: CudaModuleNV,
    pub name: *const c_char,
}

impl Default for CudaFunctionCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CUDA_FUNCTION_CREATE_INFO_NV,
            next: ptr::null(),
            module: CudaModuleNV::default(),
            name: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCudaLaunchInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CudaLaunchInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub function: CudaFunctionNV,
    pub grid_dim_x: u32,
    pub grid_dim_y: u32,
    pub grid_dim_z: u32,
    pub block_dim_x: u32,
    pub block_dim_y: u32,
    pub block_dim_z: u32,
    pub shared_mem_bytes: u32,
    pub param_count: usize,
    pub params: *const c_void,
    pub extra_count: usize,
    pub extras: *const c_void,
}

impl Default for CudaLaunchInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CUDA_LAUNCH_INFO_NV,
            next: ptr::null(),
            function: CudaFunctionNV::default(),
            grid_dim_x: u32::default(),
            grid_dim_y: u32::default(),
            grid_dim_z: u32::default(),
            block_dim_x: u32::default(),
            block_dim_y: u32::default(),
            block_dim_z: u32::default(),
            shared_mem_bytes: u32::default(),
            param_count: usize::default(),
            params: ptr::null(),
            extra_count: usize::default(),
            extras: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCudaModuleCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct CudaModuleCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub data_size: usize,
    pub data: *const c_void,
}

impl Default for CudaModuleCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::CUDA_MODULE_CREATE_INFO_NV,
            next: ptr::null(),
            data_size: usize::default(),
            data: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkD3D12FenceSubmitInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct D3D12FenceSubmitInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub wait_semaphore_values_count: u32,
    pub wait_semaphore_values: *const u64,
    pub signal_semaphore_values_count: u32,
    pub signal_semaphore_values: *const u64,
}

impl Default for D3D12FenceSubmitInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::D3D12_FENCE_SUBMIT_INFO_KHR,
            next: ptr::null(),
            wait_semaphore_values_count: u32::default(),
            wait_semaphore_values: ptr::null(),
            signal_semaphore_values_count: u32::default(),
            signal_semaphore_values: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDebugMarkerMarkerInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct DebugMarkerMarkerInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub marker_name: *const c_char,
    pub color: [f32; 4],
}

impl Default for DebugMarkerMarkerInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEBUG_MARKER_MARKER_INFO_EXT,
            next: ptr::null(),
            marker_name: ptr::null(),
            color: [f32::default(); 4],
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDebugMarkerObjectNameInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DebugMarkerObjectNameInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub object_type: DebugReportObjectTypeEXT,
    pub object: u64,
    pub object_name: *const c_char,
}

impl Default for DebugMarkerObjectNameInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEBUG_MARKER_OBJECT_NAME_INFO_EXT,
            next: ptr::null(),
            object_type: DebugReportObjectTypeEXT::default(),
            object: u64::default(),
            object_name: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDebugMarkerObjectTagInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DebugMarkerObjectTagInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub object_type: DebugReportObjectTypeEXT,
    pub object: u64,
    pub tag_name: u64,
    pub tag_size: usize,
    pub tag: *const c_void,
}

impl Default for DebugMarkerObjectTagInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEBUG_MARKER_OBJECT_TAG_INFO_EXT,
            next: ptr::null(),
            object_type: DebugReportObjectTypeEXT::default(),
            object: u64::default(),
            tag_name: u64::default(),
            tag_size: usize::default(),
            tag: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDebugReportCallbackCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone)]
pub struct DebugReportCallbackCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: DebugReportFlagsEXT,
    pub callback: PFN_vkDebugReportCallbackEXT,
    pub user_data: *mut c_void,
}

impl fmt::Debug for DebugReportCallbackCreateInfoEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("DebugReportCallbackCreateInfoEXT")
            .field("s_type", &self.s_type)
            .field("next", &self.next)
            .field("flags", &self.flags)
            .field("callback", &(self.callback.map(|f| f as *const u8)))
            .field("user_data", &self.user_data)
            .finish()
    }
}

impl Default for DebugReportCallbackCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
            next: ptr::null(),
            flags: DebugReportFlagsEXT::default(),
            callback: PFN_vkDebugReportCallbackEXT::default(),
            user_data: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDebugUtilsLabelEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct DebugUtilsLabelEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub label_name: *const c_char,
    pub color: [f32; 4],
}

impl Default for DebugUtilsLabelEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEBUG_UTILS_LABEL_EXT,
            next: ptr::null(),
            label_name: ptr::null(),
            color: [f32::default(); 4],
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDebugUtilsMessengerCallbackDataEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DebugUtilsMessengerCallbackDataEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: DebugUtilsMessengerCallbackDataFlagsEXT,
    pub message_id_name: *const c_char,
    pub message_id_number: i32,
    pub message: *const c_char,
    pub queue_label_count: u32,
    pub queue_labels: *const DebugUtilsLabelEXT,
    pub cmd_buf_label_count: u32,
    pub cmd_buf_labels: *const DebugUtilsLabelEXT,
    pub object_count: u32,
    pub objects: *const DebugUtilsObjectNameInfoEXT,
}

impl Default for DebugUtilsMessengerCallbackDataEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT,
            next: ptr::null(),
            flags: DebugUtilsMessengerCallbackDataFlagsEXT::default(),
            message_id_name: ptr::null(),
            message_id_number: i32::default(),
            message: ptr::null(),
            queue_label_count: u32::default(),
            queue_labels: ptr::null(),
            cmd_buf_label_count: u32::default(),
            cmd_buf_labels: ptr::null(),
            object_count: u32::default(),
            objects: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDebugUtilsMessengerCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone)]
pub struct DebugUtilsMessengerCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: DebugUtilsMessengerCreateFlagsEXT,
    pub message_severity: DebugUtilsMessageSeverityFlagsEXT,
    pub message_type: DebugUtilsMessageTypeFlagsEXT,
    pub user_callback: PFN_vkDebugUtilsMessengerCallbackEXT,
    pub user_data: *mut c_void,
}

impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("DebugUtilsMessengerCreateInfoEXT")
            .field("s_type", &self.s_type)
            .field("next", &self.next)
            .field("flags", &self.flags)
            .field("message_severity", &self.message_severity)
            .field("message_type", &self.message_type)
            .field(
                "user_callback",
                &(self.user_callback.map(|f| f as *const u8)),
            )
            .field("user_data", &self.user_data)
            .finish()
    }
}

impl Default for DebugUtilsMessengerCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
            next: ptr::null(),
            flags: DebugUtilsMessengerCreateFlagsEXT::default(),
            message_severity: DebugUtilsMessageSeverityFlagsEXT::default(),
            message_type: DebugUtilsMessageTypeFlagsEXT::default(),
            user_callback: PFN_vkDebugUtilsMessengerCallbackEXT::default(),
            user_data: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDebugUtilsObjectNameInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DebugUtilsObjectNameInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub object_type: ObjectType,
    pub object_handle: u64,
    pub object_name: *const c_char,
}

impl Default for DebugUtilsObjectNameInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
            next: ptr::null(),
            object_type: ObjectType::default(),
            object_handle: u64::default(),
            object_name: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDebugUtilsObjectTagInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DebugUtilsObjectTagInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub object_type: ObjectType,
    pub object_handle: u64,
    pub tag_name: u64,
    pub tag_size: usize,
    pub tag: *const c_void,
}

impl Default for DebugUtilsObjectTagInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEBUG_UTILS_OBJECT_TAG_INFO_EXT,
            next: ptr::null(),
            object_type: ObjectType::default(),
            object_handle: u64::default(),
            tag_name: u64::default(),
            tag_size: usize::default(),
            tag: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDecompressMemoryRegionNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DecompressMemoryRegionNV {
    pub src_address: DeviceAddress,
    pub dst_address: DeviceAddress,
    pub compressed_size: DeviceSize,
    pub decompressed_size: DeviceSize,
    pub decompression_method: MemoryDecompressionMethodFlagsNV,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDedicatedAllocationBufferCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DedicatedAllocationBufferCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub dedicated_allocation: Bool32,
}

impl Default for DedicatedAllocationBufferCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
            next: ptr::null(),
            dedicated_allocation: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDedicatedAllocationImageCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DedicatedAllocationImageCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub dedicated_allocation: Bool32,
}

impl Default for DedicatedAllocationImageCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV,
            next: ptr::null(),
            dedicated_allocation: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDedicatedAllocationMemoryAllocateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DedicatedAllocationMemoryAllocateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub image: Image,
    pub buffer: Buffer,
}

impl Default for DedicatedAllocationMemoryAllocateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV,
            next: ptr::null(),
            image: Image::default(),
            buffer: Buffer::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDependencyInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DependencyInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub dependency_flags: DependencyFlags,
    pub memory_barrier_count: u32,
    pub memory_barriers: *const MemoryBarrier2,
    pub buffer_memory_barrier_count: u32,
    pub buffer_memory_barriers: *const BufferMemoryBarrier2,
    pub image_memory_barrier_count: u32,
    pub image_memory_barriers: *const ImageMemoryBarrier2,
}

impl Default for DependencyInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEPENDENCY_INFO,
            next: ptr::null(),
            dependency_flags: DependencyFlags::default(),
            memory_barrier_count: u32::default(),
            memory_barriers: ptr::null(),
            buffer_memory_barrier_count: u32::default(),
            buffer_memory_barriers: ptr::null(),
            image_memory_barrier_count: u32::default(),
            image_memory_barriers: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDepthBiasInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct DepthBiasInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub depth_bias_constant_factor: f32,
    pub depth_bias_clamp: f32,
    pub depth_bias_slope_factor: f32,
}

impl Default for DepthBiasInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEPTH_BIAS_INFO_EXT,
            next: ptr::null(),
            depth_bias_constant_factor: f32::default(),
            depth_bias_clamp: f32::default(),
            depth_bias_slope_factor: f32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDepthBiasRepresentationInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DepthBiasRepresentationInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub depth_bias_representation: DepthBiasRepresentationEXT,
    pub depth_bias_exact: Bool32,
}

impl Default for DepthBiasRepresentationInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEPTH_BIAS_REPRESENTATION_INFO_EXT,
            next: ptr::null(),
            depth_bias_representation: DepthBiasRepresentationEXT::default(),
            depth_bias_exact: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDepthClampRangeEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq)]
pub struct DepthClampRangeEXT {
    pub min_depth_clamp: f32,
    pub max_depth_clamp: f32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorAddressInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorAddressInfoEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub address: DeviceAddress,
    pub range: DeviceSize,
    pub format: Format,
}

impl Default for DescriptorAddressInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DESCRIPTOR_ADDRESS_INFO_EXT,
            next: ptr::null_mut(),
            address: DeviceAddress::default(),
            range: DeviceSize::default(),
            format: Format::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorBufferBindingInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorBufferBindingInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub address: DeviceAddress,
    pub usage: BufferUsageFlags,
}

impl Default for DescriptorBufferBindingInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DESCRIPTOR_BUFFER_BINDING_INFO_EXT,
            next: ptr::null(),
            address: DeviceAddress::default(),
            usage: BufferUsageFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorBufferBindingPushDescriptorBufferHandleEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorBufferBindingPushDescriptorBufferHandleEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub buffer: Buffer,
}

impl Default for DescriptorBufferBindingPushDescriptorBufferHandleEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT,
            next: ptr::null(),
            buffer: Buffer::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorBufferInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorBufferInfo {
    pub buffer: Buffer,
    pub offset: DeviceSize,
    pub range: DeviceSize,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorGetInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorGetInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub type_: DescriptorType,
    pub data: DescriptorDataEXT,
}

impl Default for DescriptorGetInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DESCRIPTOR_GET_INFO_EXT,
            next: ptr::null(),
            type_: DescriptorType::default(),
            data: DescriptorDataEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorImageInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorImageInfo {
    pub sampler: Sampler,
    pub image_view: ImageView,
    pub image_layout: ImageLayout,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorPoolCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorPoolCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: DescriptorPoolCreateFlags,
    pub max_sets: u32,
    pub pool_size_count: u32,
    pub pool_sizes: *const DescriptorPoolSize,
}

impl Default for DescriptorPoolCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DESCRIPTOR_POOL_CREATE_INFO,
            next: ptr::null(),
            flags: DescriptorPoolCreateFlags::default(),
            max_sets: u32::default(),
            pool_size_count: u32::default(),
            pool_sizes: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorPoolInlineUniformBlockCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorPoolInlineUniformBlockCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub max_inline_uniform_block_bindings: u32,
}

impl Default for DescriptorPoolInlineUniformBlockCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO,
            next: ptr::null(),
            max_inline_uniform_block_bindings: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorPoolSize.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorPoolSize {
    pub type_: DescriptorType,
    pub descriptor_count: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorSetAllocateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorSetAllocateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub descriptor_pool: DescriptorPool,
    pub descriptor_set_count: u32,
    pub set_layouts: *const DescriptorSetLayout,
}

impl Default for DescriptorSetAllocateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DESCRIPTOR_SET_ALLOCATE_INFO,
            next: ptr::null(),
            descriptor_pool: DescriptorPool::default(),
            descriptor_set_count: u32::default(),
            set_layouts: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorSetBindingReferenceVALVE.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorSetBindingReferenceVALVE {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub descriptor_set_layout: DescriptorSetLayout,
    pub binding: u32,
}

impl Default for DescriptorSetBindingReferenceVALVE {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE,
            next: ptr::null(),
            descriptor_set_layout: DescriptorSetLayout::default(),
            binding: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorSetLayoutBinding.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorSetLayoutBinding {
    pub binding: u32,
    pub descriptor_type: DescriptorType,
    pub descriptor_count: u32,
    pub stage_flags: ShaderStageFlags,
    pub immutable_samplers: *const Sampler,
}

impl Default for DescriptorSetLayoutBinding {
    #[inline]
    fn default() -> Self {
        Self {
            binding: u32::default(),
            descriptor_type: DescriptorType::default(),
            descriptor_count: u32::default(),
            stage_flags: ShaderStageFlags::default(),
            immutable_samplers: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorSetLayoutBindingFlagsCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorSetLayoutBindingFlagsCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub binding_count: u32,
    pub binding_flags: *const DescriptorBindingFlags,
}

impl Default for DescriptorSetLayoutBindingFlagsCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
            next: ptr::null(),
            binding_count: u32::default(),
            binding_flags: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorSetLayoutCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorSetLayoutCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: DescriptorSetLayoutCreateFlags,
    pub binding_count: u32,
    pub bindings: *const DescriptorSetLayoutBinding,
}

impl Default for DescriptorSetLayoutCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
            next: ptr::null(),
            flags: DescriptorSetLayoutCreateFlags::default(),
            binding_count: u32::default(),
            bindings: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorSetLayoutHostMappingInfoVALVE.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorSetLayoutHostMappingInfoVALVE {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub descriptor_offset: usize,
    pub descriptor_size: u32,
}

impl Default for DescriptorSetLayoutHostMappingInfoVALVE {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE,
            next: ptr::null_mut(),
            descriptor_offset: usize::default(),
            descriptor_size: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorSetLayoutSupport.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorSetLayoutSupport {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub supported: Bool32,
}

impl Default for DescriptorSetLayoutSupport {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DESCRIPTOR_SET_LAYOUT_SUPPORT,
            next: ptr::null_mut(),
            supported: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorSetVariableDescriptorCountAllocateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorSetVariableDescriptorCountAllocateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub descriptor_set_count: u32,
    pub descriptor_counts: *const u32,
}

impl Default for DescriptorSetVariableDescriptorCountAllocateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,
            next: ptr::null(),
            descriptor_set_count: u32::default(),
            descriptor_counts: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorSetVariableDescriptorCountLayoutSupport.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorSetVariableDescriptorCountLayoutSupport {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_variable_descriptor_count: u32,
}

impl Default for DescriptorSetVariableDescriptorCountLayoutSupport {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT,
            next: ptr::null_mut(),
            max_variable_descriptor_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorUpdateTemplateCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: DescriptorUpdateTemplateCreateFlags,
    pub descriptor_update_entry_count: u32,
    pub descriptor_update_entries: *const DescriptorUpdateTemplateEntry,
    pub template_type: DescriptorUpdateTemplateType,
    pub descriptor_set_layout: DescriptorSetLayout,
    pub pipeline_bind_point: PipelineBindPoint,
    pub pipeline_layout: PipelineLayout,
    pub set: u32,
}

impl Default for DescriptorUpdateTemplateCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
            next: ptr::null(),
            flags: DescriptorUpdateTemplateCreateFlags::default(),
            descriptor_update_entry_count: u32::default(),
            descriptor_update_entries: ptr::null(),
            template_type: DescriptorUpdateTemplateType::default(),
            descriptor_set_layout: DescriptorSetLayout::default(),
            pipeline_bind_point: PipelineBindPoint::default(),
            pipeline_layout: PipelineLayout::default(),
            set: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateEntry.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DescriptorUpdateTemplateEntry {
    pub dst_binding: u32,
    pub dst_array_element: u32,
    pub descriptor_count: u32,
    pub descriptor_type: DescriptorType,
    pub offset: usize,
    pub stride: usize,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceAddressBindingCallbackDataEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceAddressBindingCallbackDataEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub flags: DeviceAddressBindingFlagsEXT,
    pub base_address: DeviceAddress,
    pub size: DeviceSize,
    pub binding_type: DeviceAddressBindingTypeEXT,
}

impl Default for DeviceAddressBindingCallbackDataEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT,
            next: ptr::null_mut(),
            flags: DeviceAddressBindingFlagsEXT::default(),
            base_address: DeviceAddress::default(),
            size: DeviceSize::default(),
            binding_type: DeviceAddressBindingTypeEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceBufferMemoryRequirements.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceBufferMemoryRequirements {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub create_info: *const BufferCreateInfo,
}

impl Default for DeviceBufferMemoryRequirements {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_BUFFER_MEMORY_REQUIREMENTS,
            next: ptr::null(),
            create_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: DeviceCreateFlags,
    pub queue_create_info_count: u32,
    pub queue_create_infos: *const DeviceQueueCreateInfo,
    pub enabled_layer_count: u32,
    pub enabled_layer_names: *const *const c_char,
    pub enabled_extension_count: u32,
    pub enabled_extension_names: *const *const c_char,
    pub enabled_features: *const PhysicalDeviceFeatures,
}

impl Default for DeviceCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_CREATE_INFO,
            next: ptr::null(),
            flags: DeviceCreateFlags::default(),
            queue_create_info_count: u32::default(),
            queue_create_infos: ptr::null(),
            enabled_layer_count: u32::default(),
            enabled_layer_names: ptr::null(),
            enabled_extension_count: u32::default(),
            enabled_extension_names: ptr::null(),
            enabled_features: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceDeviceMemoryReportCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone)]
pub struct DeviceDeviceMemoryReportCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: DeviceMemoryReportFlagsEXT,
    pub user_callback: PFN_vkDeviceMemoryReportCallbackEXT,
    pub user_data: *mut c_void,
}

impl fmt::Debug for DeviceDeviceMemoryReportCreateInfoEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("DeviceDeviceMemoryReportCreateInfoEXT")
            .field("s_type", &self.s_type)
            .field("next", &self.next)
            .field("flags", &self.flags)
            .field(
                "user_callback",
                &(self.user_callback.map(|f| f as *const u8)),
            )
            .field("user_data", &self.user_data)
            .finish()
    }
}

impl Default for DeviceDeviceMemoryReportCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT,
            next: ptr::null(),
            flags: DeviceMemoryReportFlagsEXT::default(),
            user_callback: PFN_vkDeviceMemoryReportCallbackEXT::default(),
            user_data: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceDiagnosticsConfigCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceDiagnosticsConfigCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: DeviceDiagnosticsConfigFlagsNV,
}

impl Default for DeviceDiagnosticsConfigCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV,
            next: ptr::null(),
            flags: DeviceDiagnosticsConfigFlagsNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceEventInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceEventInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub device_event: DeviceEventTypeEXT,
}

impl Default for DeviceEventInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_EVENT_INFO_EXT,
            next: ptr::null(),
            device_event: DeviceEventTypeEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceFaultAddressInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DeviceFaultAddressInfoEXT {
    pub address_type: DeviceFaultAddressTypeEXT,
    pub reported_address: DeviceAddress,
    pub address_precision: DeviceSize,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceFaultCountsEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceFaultCountsEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub address_info_count: u32,
    pub vendor_info_count: u32,
    pub vendor_binary_size: DeviceSize,
}

impl Default for DeviceFaultCountsEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_FAULT_COUNTS_EXT,
            next: ptr::null_mut(),
            address_info_count: u32::default(),
            vendor_info_count: u32::default(),
            vendor_binary_size: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceFaultInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceFaultInfoEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub description: StringArray<MAX_DESCRIPTION_SIZE>,
    pub address_infos: *mut DeviceFaultAddressInfoEXT,
    pub vendor_infos: *mut DeviceFaultVendorInfoEXT,
    pub vendor_binary_data: *mut c_void,
}

impl Default for DeviceFaultInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_FAULT_INFO_EXT,
            next: ptr::null_mut(),
            description: StringArray::default(),
            address_infos: ptr::null_mut(),
            vendor_infos: ptr::null_mut(),
            vendor_binary_data: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceFaultVendorBinaryHeaderVersionOneEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DeviceFaultVendorBinaryHeaderVersionOneEXT {
    pub header_size: u32,
    pub header_version: DeviceFaultVendorBinaryHeaderVersionEXT,
    pub vendor_id: u32,
    pub device_id: u32,
    pub driver_version: u32,
    pub pipeline_cache_uuid: ByteArray<UUID_SIZE>,
    pub application_name_offset: u32,
    pub application_version: u32,
    pub engine_name_offset: u32,
    pub engine_version: u32,
    pub api_version: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceFaultVendorInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DeviceFaultVendorInfoEXT {
    pub description: StringArray<MAX_DESCRIPTION_SIZE>,
    pub vendor_fault_code: u64,
    pub vendor_fault_data: u64,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceGroupBindSparseInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceGroupBindSparseInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub resource_device_index: u32,
    pub memory_device_index: u32,
}

impl Default for DeviceGroupBindSparseInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_GROUP_BIND_SPARSE_INFO,
            next: ptr::null(),
            resource_device_index: u32::default(),
            memory_device_index: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceGroupCommandBufferBeginInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceGroupCommandBufferBeginInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub device_mask: u32,
}

impl Default for DeviceGroupCommandBufferBeginInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
            next: ptr::null(),
            device_mask: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceGroupDeviceCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceGroupDeviceCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub physical_device_count: u32,
    pub physical_devices: *const PhysicalDevice,
}

impl Default for DeviceGroupDeviceCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_GROUP_DEVICE_CREATE_INFO,
            next: ptr::null(),
            physical_device_count: u32::default(),
            physical_devices: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceGroupPresentCapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceGroupPresentCapabilitiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub present_mask: [u32; MAX_DEVICE_GROUP_SIZE],
    pub modes: DeviceGroupPresentModeFlagsKHR,
}

impl Default for DeviceGroupPresentCapabilitiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR,
            next: ptr::null_mut(),
            present_mask: [u32::default(); MAX_DEVICE_GROUP_SIZE],
            modes: DeviceGroupPresentModeFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceGroupPresentInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceGroupPresentInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub swapchain_count: u32,
    pub device_masks: *const u32,
    pub mode: DeviceGroupPresentModeFlagsKHR,
}

impl Default for DeviceGroupPresentInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_GROUP_PRESENT_INFO_KHR,
            next: ptr::null(),
            swapchain_count: u32::default(),
            device_masks: ptr::null(),
            mode: DeviceGroupPresentModeFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceGroupRenderPassBeginInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceGroupRenderPassBeginInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub device_mask: u32,
    pub device_render_area_count: u32,
    pub device_render_areas: *const Rect2D,
}

impl Default for DeviceGroupRenderPassBeginInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
            next: ptr::null(),
            device_mask: u32::default(),
            device_render_area_count: u32::default(),
            device_render_areas: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceGroupSubmitInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceGroupSubmitInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub wait_semaphore_count: u32,
    pub wait_semaphore_device_indices: *const u32,
    pub command_buffer_count: u32,
    pub command_buffer_device_masks: *const u32,
    pub signal_semaphore_count: u32,
    pub signal_semaphore_device_indices: *const u32,
}

impl Default for DeviceGroupSubmitInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_GROUP_SUBMIT_INFO,
            next: ptr::null(),
            wait_semaphore_count: u32::default(),
            wait_semaphore_device_indices: ptr::null(),
            command_buffer_count: u32::default(),
            command_buffer_device_masks: ptr::null(),
            signal_semaphore_count: u32::default(),
            signal_semaphore_device_indices: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceGroupSwapchainCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceGroupSwapchainCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub modes: DeviceGroupPresentModeFlagsKHR,
}

impl Default for DeviceGroupSwapchainCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR,
            next: ptr::null(),
            modes: DeviceGroupPresentModeFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceImageMemoryRequirements.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceImageMemoryRequirements {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub create_info: *const ImageCreateInfo,
    pub plane_aspect: ImageAspectFlags,
}

impl Default for DeviceImageMemoryRequirements {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_IMAGE_MEMORY_REQUIREMENTS,
            next: ptr::null(),
            create_info: ptr::null(),
            plane_aspect: ImageAspectFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceImageSubresourceInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceImageSubresourceInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub create_info: *const ImageCreateInfo,
    pub subresource: *const ImageSubresource2,
}

impl Default for DeviceImageSubresourceInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_IMAGE_SUBRESOURCE_INFO,
            next: ptr::null(),
            create_info: ptr::null(),
            subresource: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceMemoryOpaqueCaptureAddressInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceMemoryOpaqueCaptureAddressInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub memory: DeviceMemory,
}

impl Default for DeviceMemoryOpaqueCaptureAddressInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,
            next: ptr::null(),
            memory: DeviceMemory::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceMemoryOverallocationCreateInfoAMD.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceMemoryOverallocationCreateInfoAMD {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub overallocation_behavior: MemoryOverallocationBehaviorAMD,
}

impl Default for DeviceMemoryOverallocationCreateInfoAMD {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD,
            next: ptr::null(),
            overallocation_behavior: MemoryOverallocationBehaviorAMD::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceMemoryReportCallbackDataEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceMemoryReportCallbackDataEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub flags: DeviceMemoryReportFlagsEXT,
    pub type_: DeviceMemoryReportEventTypeEXT,
    pub memory_object_id: u64,
    pub size: DeviceSize,
    pub object_type: ObjectType,
    pub object_handle: u64,
    pub heap_index: u32,
}

impl Default for DeviceMemoryReportCallbackDataEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT,
            next: ptr::null_mut(),
            flags: DeviceMemoryReportFlagsEXT::default(),
            type_: DeviceMemoryReportEventTypeEXT::default(),
            memory_object_id: u64::default(),
            size: DeviceSize::default(),
            object_type: ObjectType::default(),
            object_handle: u64::default(),
            heap_index: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDevicePipelineBinaryInternalCacheControlKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DevicePipelineBinaryInternalCacheControlKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub disable_internal_cache: Bool32,
}

impl Default for DevicePipelineBinaryInternalCacheControlKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR,
            next: ptr::null(),
            disable_internal_cache: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDevicePrivateDataCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DevicePrivateDataCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub private_data_slot_request_count: u32,
}

impl Default for DevicePrivateDataCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_PRIVATE_DATA_CREATE_INFO,
            next: ptr::null(),
            private_data_slot_request_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceQueueCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceQueueCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: DeviceQueueCreateFlags,
    pub queue_family_index: u32,
    pub queue_count: u32,
    pub queue_priorities: *const f32,
}

impl Default for DeviceQueueCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_QUEUE_CREATE_INFO,
            next: ptr::null(),
            flags: DeviceQueueCreateFlags::default(),
            queue_family_index: u32::default(),
            queue_count: u32::default(),
            queue_priorities: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceQueueGlobalPriorityCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceQueueGlobalPriorityCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub global_priority: QueueGlobalPriority,
}

impl Default for DeviceQueueGlobalPriorityCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO,
            next: ptr::null(),
            global_priority: QueueGlobalPriority::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceQueueInfo2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceQueueInfo2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: DeviceQueueCreateFlags,
    pub queue_family_index: u32,
    pub queue_index: u32,
}

impl Default for DeviceQueueInfo2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_QUEUE_INFO_2,
            next: ptr::null(),
            flags: DeviceQueueCreateFlags::default(),
            queue_family_index: u32::default(),
            queue_index: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceQueueShaderCoreControlCreateInfoARM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceQueueShaderCoreControlCreateInfoARM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_core_count: u32,
}

impl Default for DeviceQueueShaderCoreControlCreateInfoARM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM,
            next: ptr::null_mut(),
            shader_core_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DeviceSemaphoreSciSyncPoolReservationCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub semaphore_sci_sync_pool_request_count: u32,
}

impl Default for DeviceSemaphoreSciSyncPoolReservationCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DEVICE_SEMAPHORE_SCI_SYNC_POOL_RESERVATION_CREATE_INFO_NV,
            next: ptr::null(),
            semaphore_sci_sync_pool_request_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDirectDriverLoadingInfoLUNARG.html>
#[repr(C)]
#[derive(Copy, Clone)]
pub struct DirectDriverLoadingInfoLUNARG {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub flags: DirectDriverLoadingFlagsLUNARG,
    pub get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG,
}

impl fmt::Debug for DirectDriverLoadingInfoLUNARG {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("DirectDriverLoadingInfoLUNARG")
            .field("s_type", &self.s_type)
            .field("next", &self.next)
            .field("flags", &self.flags)
            .field(
                "get_instance_proc_addr",
                &(self.get_instance_proc_addr.map(|f| f as *const u8)),
            )
            .finish()
    }
}

impl Default for DirectDriverLoadingInfoLUNARG {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DIRECT_DRIVER_LOADING_INFO_LUNARG,
            next: ptr::null_mut(),
            flags: DirectDriverLoadingFlagsLUNARG::default(),
            get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDirectDriverLoadingListLUNARG.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DirectDriverLoadingListLUNARG {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub mode: DirectDriverLoadingModeLUNARG,
    pub driver_count: u32,
    pub drivers: *const DirectDriverLoadingInfoLUNARG,
}

impl Default for DirectDriverLoadingListLUNARG {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DIRECT_DRIVER_LOADING_LIST_LUNARG,
            next: ptr::null(),
            mode: DirectDriverLoadingModeLUNARG::default(),
            driver_count: u32::default(),
            drivers: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDirectFBSurfaceCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DirectFBSurfaceCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: DirectFBSurfaceCreateFlagsEXT,
    pub dfb: *mut IDirectFB,
    pub surface: *mut IDirectFBSurface,
}

impl Default for DirectFBSurfaceCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DIRECTFB_SURFACE_CREATE_INFO_EXT,
            next: ptr::null(),
            flags: DirectFBSurfaceCreateFlagsEXT::default(),
            dfb: ptr::null_mut(),
            surface: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDispatchGraphCountInfoAMDX.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
pub struct DispatchGraphCountInfoAMDX {
    pub count: u32,
    pub infos: DeviceOrHostAddressConstAMDX,
    pub stride: u64,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDispatchGraphInfoAMDX.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
pub struct DispatchGraphInfoAMDX {
    pub node_index: u32,
    pub payload_count: u32,
    pub payloads: DeviceOrHostAddressConstAMDX,
    pub payload_stride: u64,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDispatchIndirectCommand.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DispatchIndirectCommand {
    pub x: u32,
    pub y: u32,
    pub z: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplayEventInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DisplayEventInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub display_event: DisplayEventTypeEXT,
}

impl Default for DisplayEventInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DISPLAY_EVENT_INFO_EXT,
            next: ptr::null(),
            display_event: DisplayEventTypeEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplayModeCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DisplayModeCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: DisplayModeCreateFlagsKHR,
    pub parameters: DisplayModeParametersKHR,
}

impl Default for DisplayModeCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DISPLAY_MODE_CREATE_INFO_KHR,
            next: ptr::null(),
            flags: DisplayModeCreateFlagsKHR::default(),
            parameters: DisplayModeParametersKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplayModeParametersKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DisplayModeParametersKHR {
    pub visible_region: Extent2D,
    pub refresh_rate: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplayModeProperties2KHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DisplayModeProperties2KHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub display_mode_properties: DisplayModePropertiesKHR,
}

impl Default for DisplayModeProperties2KHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DISPLAY_MODE_PROPERTIES_2_KHR,
            next: ptr::null_mut(),
            display_mode_properties: DisplayModePropertiesKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplayModePropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DisplayModePropertiesKHR {
    pub display_mode: DisplayModeKHR,
    pub parameters: DisplayModeParametersKHR,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplayModeStereoPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DisplayModeStereoPropertiesNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub hdmi_3d_supported: Bool32,
}

impl Default for DisplayModeStereoPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DISPLAY_MODE_STEREO_PROPERTIES_NV,
            next: ptr::null(),
            hdmi_3d_supported: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplayNativeHdrSurfaceCapabilitiesAMD.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DisplayNativeHdrSurfaceCapabilitiesAMD {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub local_dimming_support: Bool32,
}

impl Default for DisplayNativeHdrSurfaceCapabilitiesAMD {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD,
            next: ptr::null_mut(),
            local_dimming_support: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplayPlaneCapabilities2KHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DisplayPlaneCapabilities2KHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub capabilities: DisplayPlaneCapabilitiesKHR,
}

impl Default for DisplayPlaneCapabilities2KHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DISPLAY_PLANE_CAPABILITIES_2_KHR,
            next: ptr::null_mut(),
            capabilities: DisplayPlaneCapabilitiesKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplayPlaneCapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DisplayPlaneCapabilitiesKHR {
    pub supported_alpha: DisplayPlaneAlphaFlagsKHR,
    pub min_src_position: Offset2D,
    pub max_src_position: Offset2D,
    pub min_src_extent: Extent2D,
    pub max_src_extent: Extent2D,
    pub min_dst_position: Offset2D,
    pub max_dst_position: Offset2D,
    pub min_dst_extent: Extent2D,
    pub max_dst_extent: Extent2D,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplayPlaneInfo2KHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DisplayPlaneInfo2KHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub mode: DisplayModeKHR,
    pub plane_index: u32,
}

impl Default for DisplayPlaneInfo2KHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DISPLAY_PLANE_INFO_2_KHR,
            next: ptr::null(),
            mode: DisplayModeKHR::default(),
            plane_index: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplayPlaneProperties2KHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DisplayPlaneProperties2KHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub display_plane_properties: DisplayPlanePropertiesKHR,
}

impl Default for DisplayPlaneProperties2KHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DISPLAY_PLANE_PROPERTIES_2_KHR,
            next: ptr::null_mut(),
            display_plane_properties: DisplayPlanePropertiesKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplayPlanePropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DisplayPlanePropertiesKHR {
    pub current_display: DisplayKHR,
    pub current_stack_index: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplayPowerInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DisplayPowerInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub power_state: DisplayPowerStateEXT,
}

impl Default for DisplayPowerInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DISPLAY_POWER_INFO_EXT,
            next: ptr::null(),
            power_state: DisplayPowerStateEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplayPresentInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DisplayPresentInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_rect: Rect2D,
    pub dst_rect: Rect2D,
    pub persistent: Bool32,
}

impl Default for DisplayPresentInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DISPLAY_PRESENT_INFO_KHR,
            next: ptr::null(),
            src_rect: Rect2D::default(),
            dst_rect: Rect2D::default(),
            persistent: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplayProperties2KHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DisplayProperties2KHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub display_properties: DisplayPropertiesKHR,
}

impl Default for DisplayProperties2KHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DISPLAY_PROPERTIES_2_KHR,
            next: ptr::null_mut(),
            display_properties: DisplayPropertiesKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplayPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DisplayPropertiesKHR {
    pub display: DisplayKHR,
    pub display_name: *const c_char,
    pub physical_dimensions: Extent2D,
    pub physical_resolution: Extent2D,
    pub supported_transforms: SurfaceTransformFlagsKHR,
    pub plane_reorder_possible: Bool32,
    pub persistent_content: Bool32,
}

impl Default for DisplayPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            display: DisplayKHR::default(),
            display_name: ptr::null(),
            physical_dimensions: Extent2D::default(),
            physical_resolution: Extent2D::default(),
            supported_transforms: SurfaceTransformFlagsKHR::default(),
            plane_reorder_possible: Bool32::default(),
            persistent_content: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplaySurfaceCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct DisplaySurfaceCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: DisplaySurfaceCreateFlagsKHR,
    pub display_mode: DisplayModeKHR,
    pub plane_index: u32,
    pub plane_stack_index: u32,
    pub transform: SurfaceTransformFlagsKHR,
    pub global_alpha: f32,
    pub alpha_mode: DisplayPlaneAlphaFlagsKHR,
    pub image_extent: Extent2D,
}

impl Default for DisplaySurfaceCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DISPLAY_SURFACE_CREATE_INFO_KHR,
            next: ptr::null(),
            flags: DisplaySurfaceCreateFlagsKHR::default(),
            display_mode: DisplayModeKHR::default(),
            plane_index: u32::default(),
            plane_stack_index: u32::default(),
            transform: SurfaceTransformFlagsKHR::default(),
            global_alpha: f32::default(),
            alpha_mode: DisplayPlaneAlphaFlagsKHR::default(),
            image_extent: Extent2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDisplaySurfaceStereoCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DisplaySurfaceStereoCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub stereo_type: DisplaySurfaceStereoTypeNV,
}

impl Default for DisplaySurfaceStereoCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DISPLAY_SURFACE_STEREO_CREATE_INFO_NV,
            next: ptr::null(),
            stereo_type: DisplaySurfaceStereoTypeNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDrawIndexedIndirectCommand.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DrawIndexedIndirectCommand {
    pub index_count: u32,
    pub instance_count: u32,
    pub first_index: u32,
    pub vertex_offset: i32,
    pub first_instance: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDrawIndirectCommand.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DrawIndirectCommand {
    pub vertex_count: u32,
    pub instance_count: u32,
    pub first_vertex: u32,
    pub first_instance: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDrawIndirectCountIndirectCommandEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DrawIndirectCountIndirectCommandEXT {
    pub buffer_address: DeviceAddress,
    pub stride: u32,
    pub command_count: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDrawMeshTasksIndirectCommandEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DrawMeshTasksIndirectCommandEXT {
    pub group_count_x: u32,
    pub group_count_y: u32,
    pub group_count_z: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDrawMeshTasksIndirectCommandNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DrawMeshTasksIndirectCommandNV {
    pub task_count: u32,
    pub first_task: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDrmFormatModifierProperties2EXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DrmFormatModifierProperties2EXT {
    pub drm_format_modifier: u64,
    pub drm_format_modifier_plane_count: u32,
    pub drm_format_modifier_tiling_features: FormatFeatureFlags2,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDrmFormatModifierPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct DrmFormatModifierPropertiesEXT {
    pub drm_format_modifier: u64,
    pub drm_format_modifier_plane_count: u32,
    pub drm_format_modifier_tiling_features: FormatFeatureFlags,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDrmFormatModifierPropertiesList2EXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DrmFormatModifierPropertiesList2EXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub drm_format_modifier_count: u32,
    pub drm_format_modifier_properties: *mut DrmFormatModifierProperties2EXT,
}

impl Default for DrmFormatModifierPropertiesList2EXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT,
            next: ptr::null_mut(),
            drm_format_modifier_count: u32::default(),
            drm_format_modifier_properties: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDrmFormatModifierPropertiesListEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct DrmFormatModifierPropertiesListEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub drm_format_modifier_count: u32,
    pub drm_format_modifier_properties: *mut DrmFormatModifierPropertiesEXT,
}

impl Default for DrmFormatModifierPropertiesListEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT,
            next: ptr::null_mut(),
            drm_format_modifier_count: u32::default(),
            drm_format_modifier_properties: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkEventCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct EventCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: EventCreateFlags,
}

impl Default for EventCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EVENT_CREATE_INFO,
            next: ptr::null(),
            flags: EventCreateFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExecutionGraphPipelineCreateInfoAMDX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExecutionGraphPipelineCreateInfoAMDX {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineCreateFlags,
    pub stage_count: u32,
    pub stages: *const PipelineShaderStageCreateInfo,
    pub library_info: *const PipelineLibraryCreateInfoKHR,
    pub layout: PipelineLayout,
    pub base_pipeline_handle: Pipeline,
    pub base_pipeline_index: i32,
}

impl Default for ExecutionGraphPipelineCreateInfoAMDX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX,
            next: ptr::null(),
            flags: PipelineCreateFlags::default(),
            stage_count: u32::default(),
            stages: ptr::null(),
            library_info: ptr::null(),
            layout: PipelineLayout::default(),
            base_pipeline_handle: Pipeline::default(),
            base_pipeline_index: i32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExecutionGraphPipelineScratchSizeAMDX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExecutionGraphPipelineScratchSizeAMDX {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub min_size: DeviceSize,
    pub max_size: DeviceSize,
    pub size_granularity: DeviceSize,
}

impl Default for ExecutionGraphPipelineScratchSizeAMDX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX,
            next: ptr::null_mut(),
            min_size: DeviceSize::default(),
            max_size: DeviceSize::default(),
            size_granularity: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportFenceCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportFenceCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_types: ExternalFenceHandleTypeFlags,
}

impl Default for ExportFenceCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_FENCE_CREATE_INFO,
            next: ptr::null(),
            handle_types: ExternalFenceHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportFenceSciSyncInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportFenceSciSyncInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub attributes: NvSciSyncAttrList,
}

impl Default for ExportFenceSciSyncInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_FENCE_SCI_SYNC_INFO_NV,
            next: ptr::null(),
            attributes: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportFenceWin32HandleInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportFenceWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub attributes: *const SECURITY_ATTRIBUTES,
    pub dw_access: DWORD,
    pub name: LPCWSTR,
}

impl Default for ExportFenceWin32HandleInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR,
            next: ptr::null(),
            attributes: ptr::null(),
            dw_access: DWORD::default(),
            name: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportMemoryAllocateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportMemoryAllocateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_types: ExternalMemoryHandleTypeFlags,
}

impl Default for ExportMemoryAllocateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO,
            next: ptr::null(),
            handle_types: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportMemoryAllocateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportMemoryAllocateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_types: ExternalMemoryHandleTypeFlagsNV,
}

impl Default for ExportMemoryAllocateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO_NV,
            next: ptr::null(),
            handle_types: ExternalMemoryHandleTypeFlagsNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportMemorySciBufInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportMemorySciBufInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub attributes: NvSciBufAttrList,
}

impl Default for ExportMemorySciBufInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_MEMORY_SCI_BUF_INFO_NV,
            next: ptr::null(),
            attributes: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportMemoryWin32HandleInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportMemoryWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub attributes: *const SECURITY_ATTRIBUTES,
    pub dw_access: DWORD,
    pub name: LPCWSTR,
}

impl Default for ExportMemoryWin32HandleInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
            next: ptr::null(),
            attributes: ptr::null(),
            dw_access: DWORD::default(),
            name: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportMemoryWin32HandleInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportMemoryWin32HandleInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub attributes: *const SECURITY_ATTRIBUTES,
    pub dw_access: DWORD,
}

impl Default for ExportMemoryWin32HandleInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV,
            next: ptr::null(),
            attributes: ptr::null(),
            dw_access: DWORD::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportMetalBufferInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportMetalBufferInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub mtl_buffer: MTLBuffer_id,
}

impl Default for ExportMetalBufferInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_METAL_BUFFER_INFO_EXT,
            next: ptr::null(),
            memory: DeviceMemory::default(),
            mtl_buffer: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportMetalCommandQueueInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportMetalCommandQueueInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub queue: Queue,
    pub mtl_command_queue: MTLCommandQueue_id,
}

impl Default for ExportMetalCommandQueueInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_METAL_COMMAND_QUEUE_INFO_EXT,
            next: ptr::null(),
            queue: Queue::default(),
            mtl_command_queue: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportMetalDeviceInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportMetalDeviceInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub mtl_device: MTLDevice_id,
}

impl Default for ExportMetalDeviceInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_METAL_DEVICE_INFO_EXT,
            next: ptr::null(),
            mtl_device: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportMetalIOSurfaceInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportMetalIOSurfaceInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub image: Image,
    pub io_surface: IOSurfaceRef,
}

impl Default for ExportMetalIOSurfaceInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_METAL_IO_SURFACE_INFO_EXT,
            next: ptr::null(),
            image: Image::default(),
            io_surface: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportMetalObjectCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportMetalObjectCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub export_object_type: ExportMetalObjectTypeFlagsEXT,
}

impl Default for ExportMetalObjectCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_METAL_OBJECT_CREATE_INFO_EXT,
            next: ptr::null(),
            export_object_type: ExportMetalObjectTypeFlagsEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportMetalObjectsInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportMetalObjectsInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
}

impl Default for ExportMetalObjectsInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_METAL_OBJECTS_INFO_EXT,
            next: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportMetalSharedEventInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportMetalSharedEventInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub event: Event,
    pub mtl_shared_event: MTLSharedEvent_id,
}

impl Default for ExportMetalSharedEventInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_METAL_SHARED_EVENT_INFO_EXT,
            next: ptr::null(),
            semaphore: Semaphore::default(),
            event: Event::default(),
            mtl_shared_event: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportMetalTextureInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportMetalTextureInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub image: Image,
    pub image_view: ImageView,
    pub buffer_view: BufferView,
    pub plane: ImageAspectFlags,
    pub mtl_texture: MTLTexture_id,
}

impl Default for ExportMetalTextureInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_METAL_TEXTURE_INFO_EXT,
            next: ptr::null(),
            image: Image::default(),
            image_view: ImageView::default(),
            buffer_view: BufferView::default(),
            plane: ImageAspectFlags::default(),
            mtl_texture: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportSemaphoreCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportSemaphoreCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_types: ExternalSemaphoreHandleTypeFlags,
}

impl Default for ExportSemaphoreCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_SEMAPHORE_CREATE_INFO,
            next: ptr::null(),
            handle_types: ExternalSemaphoreHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportSemaphoreSciSyncInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportSemaphoreSciSyncInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub attributes: NvSciSyncAttrList,
}

impl Default for ExportSemaphoreSciSyncInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_SEMAPHORE_SCI_SYNC_INFO_NV,
            next: ptr::null(),
            attributes: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportSemaphoreWin32HandleInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExportSemaphoreWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub attributes: *const SECURITY_ATTRIBUTES,
    pub dw_access: DWORD,
    pub name: LPCWSTR,
}

impl Default for ExportSemaphoreWin32HandleInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
            next: ptr::null(),
            attributes: ptr::null(),
            dw_access: DWORD::default(),
            name: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExtensionProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ExtensionProperties {
    pub extension_name: StringArray<MAX_EXTENSION_NAME_SIZE>,
    pub spec_version: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExtent2D.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct Extent2D {
    pub width: u32,
    pub height: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExtent3D.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct Extent3D {
    pub width: u32,
    pub height: u32,
    pub depth: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalBufferProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExternalBufferProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub external_memory_properties: ExternalMemoryProperties,
}

impl Default for ExternalBufferProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXTERNAL_BUFFER_PROPERTIES,
            next: ptr::null_mut(),
            external_memory_properties: ExternalMemoryProperties::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalFenceProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExternalFenceProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub export_from_imported_handle_types: ExternalFenceHandleTypeFlags,
    pub compatible_handle_types: ExternalFenceHandleTypeFlags,
    pub external_fence_features: ExternalFenceFeatureFlags,
}

impl Default for ExternalFenceProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXTERNAL_FENCE_PROPERTIES,
            next: ptr::null_mut(),
            export_from_imported_handle_types: ExternalFenceHandleTypeFlags::default(),
            compatible_handle_types: ExternalFenceHandleTypeFlags::default(),
            external_fence_features: ExternalFenceFeatureFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalFormatANDROID.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExternalFormatANDROID {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub external_format: u64,
}

impl Default for ExternalFormatANDROID {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXTERNAL_FORMAT_ANDROID,
            next: ptr::null_mut(),
            external_format: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalFormatQNX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExternalFormatQNX {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub external_format: u64,
}

impl Default for ExternalFormatQNX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXTERNAL_FORMAT_QNX,
            next: ptr::null_mut(),
            external_format: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalImageFormatProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExternalImageFormatProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub external_memory_properties: ExternalMemoryProperties,
}

impl Default for ExternalImageFormatProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXTERNAL_IMAGE_FORMAT_PROPERTIES,
            next: ptr::null_mut(),
            external_memory_properties: ExternalMemoryProperties::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalImageFormatPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ExternalImageFormatPropertiesNV {
    pub image_format_properties: ImageFormatProperties,
    pub external_memory_features: ExternalMemoryFeatureFlagsNV,
    pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV,
    pub compatible_handle_types: ExternalMemoryHandleTypeFlagsNV,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalMemoryAcquireUnmodifiedEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExternalMemoryAcquireUnmodifiedEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub acquire_unmodified_memory: Bool32,
}

impl Default for ExternalMemoryAcquireUnmodifiedEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT,
            next: ptr::null(),
            acquire_unmodified_memory: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalMemoryBufferCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExternalMemoryBufferCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_types: ExternalMemoryHandleTypeFlags,
}

impl Default for ExternalMemoryBufferCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
            next: ptr::null(),
            handle_types: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalMemoryImageCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExternalMemoryImageCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_types: ExternalMemoryHandleTypeFlags,
}

impl Default for ExternalMemoryImageCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
            next: ptr::null(),
            handle_types: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalMemoryImageCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExternalMemoryImageCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_types: ExternalMemoryHandleTypeFlagsNV,
}

impl Default for ExternalMemoryImageCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV,
            next: ptr::null(),
            handle_types: ExternalMemoryHandleTypeFlagsNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalMemoryProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ExternalMemoryProperties {
    pub external_memory_features: ExternalMemoryFeatureFlags,
    pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlags,
    pub compatible_handle_types: ExternalMemoryHandleTypeFlags,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalSemaphoreProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ExternalSemaphoreProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags,
    pub compatible_handle_types: ExternalSemaphoreHandleTypeFlags,
    pub external_semaphore_features: ExternalSemaphoreFeatureFlags,
}

impl Default for ExternalSemaphoreProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::EXTERNAL_SEMAPHORE_PROPERTIES,
            next: ptr::null_mut(),
            export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags::default(),
            compatible_handle_types: ExternalSemaphoreHandleTypeFlags::default(),
            external_semaphore_features: ExternalSemaphoreFeatureFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFenceCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct FenceCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: FenceCreateFlags,
}

impl Default for FenceCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::FENCE_CREATE_INFO,
            next: ptr::null(),
            flags: FenceCreateFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFenceGetFdInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct FenceGetFdInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub fence: Fence,
    pub handle_type: ExternalFenceHandleTypeFlags,
}

impl Default for FenceGetFdInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::FENCE_GET_FD_INFO_KHR,
            next: ptr::null(),
            fence: Fence::default(),
            handle_type: ExternalFenceHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFenceGetSciSyncInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct FenceGetSciSyncInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub fence: Fence,
    pub handle_type: ExternalFenceHandleTypeFlags,
}

impl Default for FenceGetSciSyncInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::FENCE_GET_SCI_SYNC_INFO_NV,
            next: ptr::null(),
            fence: Fence::default(),
            handle_type: ExternalFenceHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFenceGetWin32HandleInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct FenceGetWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub fence: Fence,
    pub handle_type: ExternalFenceHandleTypeFlags,
}

impl Default for FenceGetWin32HandleInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::FENCE_GET_WIN32_HANDLE_INFO_KHR,
            next: ptr::null(),
            fence: Fence::default(),
            handle_type: ExternalFenceHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFilterCubicImageViewImageFormatPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct FilterCubicImageViewImageFormatPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub filter_cubic: Bool32,
    pub filter_cubic_minmax: Bool32,
}

impl Default for FilterCubicImageViewImageFormatPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT,
            next: ptr::null_mut(),
            filter_cubic: Bool32::default(),
            filter_cubic_minmax: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFormatProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct FormatProperties {
    pub linear_tiling_features: FormatFeatureFlags,
    pub optimal_tiling_features: FormatFeatureFlags,
    pub buffer_features: FormatFeatureFlags,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFormatProperties2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct FormatProperties2 {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub format_properties: FormatProperties,
}

impl Default for FormatProperties2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::FORMAT_PROPERTIES_2,
            next: ptr::null_mut(),
            format_properties: FormatProperties::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFormatProperties3.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct FormatProperties3 {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub linear_tiling_features: FormatFeatureFlags2,
    pub optimal_tiling_features: FormatFeatureFlags2,
    pub buffer_features: FormatFeatureFlags2,
}

impl Default for FormatProperties3 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::FORMAT_PROPERTIES_3,
            next: ptr::null_mut(),
            linear_tiling_features: FormatFeatureFlags2::default(),
            optimal_tiling_features: FormatFeatureFlags2::default(),
            buffer_features: FormatFeatureFlags2::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFragmentShadingRateAttachmentInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct FragmentShadingRateAttachmentInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub fragment_shading_rate_attachment: *const AttachmentReference2,
    pub shading_rate_attachment_texel_size: Extent2D,
}

impl Default for FragmentShadingRateAttachmentInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR,
            next: ptr::null(),
            fragment_shading_rate_attachment: ptr::null(),
            shading_rate_attachment_texel_size: Extent2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFrameBoundaryEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct FrameBoundaryEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: FrameBoundaryFlagsEXT,
    pub frame_id: u64,
    pub image_count: u32,
    pub images: *const Image,
    pub buffer_count: u32,
    pub buffers: *const Buffer,
    pub tag_name: u64,
    pub tag_size: usize,
    pub tag: *const c_void,
}

impl Default for FrameBoundaryEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::FRAME_BOUNDARY_EXT,
            next: ptr::null(),
            flags: FrameBoundaryFlagsEXT::default(),
            frame_id: u64::default(),
            image_count: u32::default(),
            images: ptr::null(),
            buffer_count: u32::default(),
            buffers: ptr::null(),
            tag_name: u64::default(),
            tag_size: usize::default(),
            tag: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFramebufferAttachmentImageInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct FramebufferAttachmentImageInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: ImageCreateFlags,
    pub usage: ImageUsageFlags,
    pub width: u32,
    pub height: u32,
    pub layer_count: u32,
    pub view_format_count: u32,
    pub view_formats: *const Format,
}

impl Default for FramebufferAttachmentImageInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,
            next: ptr::null(),
            flags: ImageCreateFlags::default(),
            usage: ImageUsageFlags::default(),
            width: u32::default(),
            height: u32::default(),
            layer_count: u32::default(),
            view_format_count: u32::default(),
            view_formats: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFramebufferAttachmentsCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct FramebufferAttachmentsCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub attachment_image_info_count: u32,
    pub attachment_image_infos: *const FramebufferAttachmentImageInfo,
}

impl Default for FramebufferAttachmentsCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO,
            next: ptr::null(),
            attachment_image_info_count: u32::default(),
            attachment_image_infos: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFramebufferCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct FramebufferCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: FramebufferCreateFlags,
    pub render_pass: RenderPass,
    pub attachment_count: u32,
    pub attachments: *const ImageView,
    pub width: u32,
    pub height: u32,
    pub layers: u32,
}

impl Default for FramebufferCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::FRAMEBUFFER_CREATE_INFO,
            next: ptr::null(),
            flags: FramebufferCreateFlags::default(),
            render_pass: RenderPass::default(),
            attachment_count: u32::default(),
            attachments: ptr::null(),
            width: u32::default(),
            height: u32::default(),
            layers: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFramebufferMixedSamplesCombinationNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct FramebufferMixedSamplesCombinationNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub coverage_reduction_mode: CoverageReductionModeNV,
    pub rasterization_samples: SampleCountFlags,
    pub depth_stencil_samples: SampleCountFlags,
    pub color_samples: SampleCountFlags,
}

impl Default for FramebufferMixedSamplesCombinationNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV,
            next: ptr::null_mut(),
            coverage_reduction_mode: CoverageReductionModeNV::default(),
            rasterization_samples: SampleCountFlags::default(),
            depth_stencil_samples: SampleCountFlags::default(),
            color_samples: SampleCountFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkGeneratedCommandsInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct GeneratedCommandsInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub shader_stages: ShaderStageFlags,
    pub indirect_execution_set: IndirectExecutionSetEXT,
    pub indirect_commands_layout: IndirectCommandsLayoutEXT,
    pub indirect_address: DeviceAddress,
    pub indirect_address_size: DeviceSize,
    pub preprocess_address: DeviceAddress,
    pub preprocess_size: DeviceSize,
    pub max_sequence_count: u32,
    pub sequence_count_address: DeviceAddress,
    pub max_draw_count: u32,
}

impl Default for GeneratedCommandsInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::GENERATED_COMMANDS_INFO_EXT,
            next: ptr::null(),
            shader_stages: ShaderStageFlags::default(),
            indirect_execution_set: IndirectExecutionSetEXT::default(),
            indirect_commands_layout: IndirectCommandsLayoutEXT::default(),
            indirect_address: DeviceAddress::default(),
            indirect_address_size: DeviceSize::default(),
            preprocess_address: DeviceAddress::default(),
            preprocess_size: DeviceSize::default(),
            max_sequence_count: u32::default(),
            sequence_count_address: DeviceAddress::default(),
            max_draw_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkGeneratedCommandsInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct GeneratedCommandsInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub pipeline_bind_point: PipelineBindPoint,
    pub pipeline: Pipeline,
    pub indirect_commands_layout: IndirectCommandsLayoutNV,
    pub stream_count: u32,
    pub streams: *const IndirectCommandsStreamNV,
    pub sequences_count: u32,
    pub preprocess_buffer: Buffer,
    pub preprocess_offset: DeviceSize,
    pub preprocess_size: DeviceSize,
    pub sequences_count_buffer: Buffer,
    pub sequences_count_offset: DeviceSize,
    pub sequences_index_buffer: Buffer,
    pub sequences_index_offset: DeviceSize,
}

impl Default for GeneratedCommandsInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::GENERATED_COMMANDS_INFO_NV,
            next: ptr::null(),
            pipeline_bind_point: PipelineBindPoint::default(),
            pipeline: Pipeline::default(),
            indirect_commands_layout: IndirectCommandsLayoutNV::default(),
            stream_count: u32::default(),
            streams: ptr::null(),
            sequences_count: u32::default(),
            preprocess_buffer: Buffer::default(),
            preprocess_offset: DeviceSize::default(),
            preprocess_size: DeviceSize::default(),
            sequences_count_buffer: Buffer::default(),
            sequences_count_offset: DeviceSize::default(),
            sequences_index_buffer: Buffer::default(),
            sequences_index_offset: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkGeneratedCommandsMemoryRequirementsInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct GeneratedCommandsMemoryRequirementsInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub indirect_execution_set: IndirectExecutionSetEXT,
    pub indirect_commands_layout: IndirectCommandsLayoutEXT,
    pub max_sequence_count: u32,
    pub max_draw_count: u32,
}

impl Default for GeneratedCommandsMemoryRequirementsInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT,
            next: ptr::null(),
            indirect_execution_set: IndirectExecutionSetEXT::default(),
            indirect_commands_layout: IndirectCommandsLayoutEXT::default(),
            max_sequence_count: u32::default(),
            max_draw_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkGeneratedCommandsMemoryRequirementsInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct GeneratedCommandsMemoryRequirementsInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub pipeline_bind_point: PipelineBindPoint,
    pub pipeline: Pipeline,
    pub indirect_commands_layout: IndirectCommandsLayoutNV,
    pub max_sequences_count: u32,
}

impl Default for GeneratedCommandsMemoryRequirementsInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV,
            next: ptr::null(),
            pipeline_bind_point: PipelineBindPoint::default(),
            pipeline: Pipeline::default(),
            indirect_commands_layout: IndirectCommandsLayoutNV::default(),
            max_sequences_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkGeneratedCommandsPipelineInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct GeneratedCommandsPipelineInfoEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pipeline: Pipeline,
}

impl Default for GeneratedCommandsPipelineInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::GENERATED_COMMANDS_PIPELINE_INFO_EXT,
            next: ptr::null_mut(),
            pipeline: Pipeline::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkGeneratedCommandsShaderInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct GeneratedCommandsShaderInfoEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_count: u32,
    pub shaders: *const ShaderEXT,
}

impl Default for GeneratedCommandsShaderInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::GENERATED_COMMANDS_SHADER_INFO_EXT,
            next: ptr::null_mut(),
            shader_count: u32::default(),
            shaders: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkGeometryAABBNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct GeometryAABBNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub aabb_data: Buffer,
    pub num_aab_bs: u32,
    pub stride: u32,
    pub offset: DeviceSize,
}

impl Default for GeometryAABBNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::GEOMETRY_AABB_NV,
            next: ptr::null(),
            aabb_data: Buffer::default(),
            num_aab_bs: u32::default(),
            stride: u32::default(),
            offset: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkGeometryDataNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct GeometryDataNV {
    pub triangles: GeometryTrianglesNV,
    pub aabbs: GeometryAABBNV,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkGeometryNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct GeometryNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub geometry_type: GeometryTypeKHR,
    pub geometry: GeometryDataNV,
    pub flags: GeometryFlagsKHR,
}

impl Default for GeometryNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::GEOMETRY_NV,
            next: ptr::null(),
            geometry_type: GeometryTypeKHR::default(),
            geometry: GeometryDataNV::default(),
            flags: GeometryFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkGeometryTrianglesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct GeometryTrianglesNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub vertex_data: Buffer,
    pub vertex_offset: DeviceSize,
    pub vertex_count: u32,
    pub vertex_stride: DeviceSize,
    pub vertex_format: Format,
    pub index_data: Buffer,
    pub index_offset: DeviceSize,
    pub index_count: u32,
    pub index_type: IndexType,
    pub transform_data: Buffer,
    pub transform_offset: DeviceSize,
}

impl Default for GeometryTrianglesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::GEOMETRY_TRIANGLES_NV,
            next: ptr::null(),
            vertex_data: Buffer::default(),
            vertex_offset: DeviceSize::default(),
            vertex_count: u32::default(),
            vertex_stride: DeviceSize::default(),
            vertex_format: Format::default(),
            index_data: Buffer::default(),
            index_offset: DeviceSize::default(),
            index_count: u32::default(),
            index_type: IndexType::default(),
            transform_data: Buffer::default(),
            transform_offset: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkGetLatencyMarkerInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct GetLatencyMarkerInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub timing_count: u32,
    pub timings: *mut LatencyTimingsFrameReportNV,
}

impl Default for GetLatencyMarkerInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::GET_LATENCY_MARKER_INFO_NV,
            next: ptr::null(),
            timing_count: u32::default(),
            timings: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkGraphicsPipelineCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct GraphicsPipelineCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineCreateFlags,
    pub stage_count: u32,
    pub stages: *const PipelineShaderStageCreateInfo,
    pub vertex_input_state: *const PipelineVertexInputStateCreateInfo,
    pub input_assembly_state: *const PipelineInputAssemblyStateCreateInfo,
    pub tessellation_state: *const PipelineTessellationStateCreateInfo,
    pub viewport_state: *const PipelineViewportStateCreateInfo,
    pub rasterization_state: *const PipelineRasterizationStateCreateInfo,
    pub multisample_state: *const PipelineMultisampleStateCreateInfo,
    pub depth_stencil_state: *const PipelineDepthStencilStateCreateInfo,
    pub color_blend_state: *const PipelineColorBlendStateCreateInfo,
    pub dynamic_state: *const PipelineDynamicStateCreateInfo,
    pub layout: PipelineLayout,
    pub render_pass: RenderPass,
    pub subpass: u32,
    pub base_pipeline_handle: Pipeline,
    pub base_pipeline_index: i32,
}

impl Default for GraphicsPipelineCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::GRAPHICS_PIPELINE_CREATE_INFO,
            next: ptr::null(),
            flags: PipelineCreateFlags::default(),
            stage_count: u32::default(),
            stages: ptr::null(),
            vertex_input_state: ptr::null(),
            input_assembly_state: ptr::null(),
            tessellation_state: ptr::null(),
            viewport_state: ptr::null(),
            rasterization_state: ptr::null(),
            multisample_state: ptr::null(),
            depth_stencil_state: ptr::null(),
            color_blend_state: ptr::null(),
            dynamic_state: ptr::null(),
            layout: PipelineLayout::default(),
            render_pass: RenderPass::default(),
            subpass: u32::default(),
            base_pipeline_handle: Pipeline::default(),
            base_pipeline_index: i32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkGraphicsPipelineLibraryCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct GraphicsPipelineLibraryCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: GraphicsPipelineLibraryFlagsEXT,
}

impl Default for GraphicsPipelineLibraryCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT,
            next: ptr::null(),
            flags: GraphicsPipelineLibraryFlagsEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkGraphicsPipelineShaderGroupsCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct GraphicsPipelineShaderGroupsCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub group_count: u32,
    pub groups: *const GraphicsShaderGroupCreateInfoNV,
    pub pipeline_count: u32,
    pub pipelines: *const Pipeline,
}

impl Default for GraphicsPipelineShaderGroupsCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV,
            next: ptr::null(),
            group_count: u32::default(),
            groups: ptr::null(),
            pipeline_count: u32::default(),
            pipelines: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkGraphicsShaderGroupCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct GraphicsShaderGroupCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub stage_count: u32,
    pub stages: *const PipelineShaderStageCreateInfo,
    pub vertex_input_state: *const PipelineVertexInputStateCreateInfo,
    pub tessellation_state: *const PipelineTessellationStateCreateInfo,
}

impl Default for GraphicsShaderGroupCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV,
            next: ptr::null(),
            stage_count: u32::default(),
            stages: ptr::null(),
            vertex_input_state: ptr::null(),
            tessellation_state: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkHdrMetadataEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct HdrMetadataEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub display_primary_red: XYColorEXT,
    pub display_primary_green: XYColorEXT,
    pub display_primary_blue: XYColorEXT,
    pub white_point: XYColorEXT,
    pub max_luminance: f32,
    pub min_luminance: f32,
    pub max_content_light_level: f32,
    pub max_frame_average_light_level: f32,
}

impl Default for HdrMetadataEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::HDR_METADATA_EXT,
            next: ptr::null(),
            display_primary_red: XYColorEXT::default(),
            display_primary_green: XYColorEXT::default(),
            display_primary_blue: XYColorEXT::default(),
            white_point: XYColorEXT::default(),
            max_luminance: f32::default(),
            min_luminance: f32::default(),
            max_content_light_level: f32::default(),
            max_frame_average_light_level: f32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkHdrVividDynamicMetadataHUAWEI.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct HdrVividDynamicMetadataHUAWEI {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub dynamic_metadata_size: usize,
    pub dynamic_metadata: *const c_void,
}

impl Default for HdrVividDynamicMetadataHUAWEI {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::HDR_VIVID_DYNAMIC_METADATA_HUAWEI,
            next: ptr::null(),
            dynamic_metadata_size: usize::default(),
            dynamic_metadata: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkHeadlessSurfaceCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct HeadlessSurfaceCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: HeadlessSurfaceCreateFlagsEXT,
}

impl Default for HeadlessSurfaceCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::HEADLESS_SURFACE_CREATE_INFO_EXT,
            next: ptr::null(),
            flags: HeadlessSurfaceCreateFlagsEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkHostImageCopyDevicePerformanceQuery.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct HostImageCopyDevicePerformanceQuery {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub optimal_device_access: Bool32,
    pub identical_memory_layout: Bool32,
}

impl Default for HostImageCopyDevicePerformanceQuery {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY,
            next: ptr::null_mut(),
            optimal_device_access: Bool32::default(),
            identical_memory_layout: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkHostImageLayoutTransitionInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct HostImageLayoutTransitionInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub image: Image,
    pub old_layout: ImageLayout,
    pub new_layout: ImageLayout,
    pub subresource_range: ImageSubresourceRange,
}

impl Default for HostImageLayoutTransitionInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::HOST_IMAGE_LAYOUT_TRANSITION_INFO,
            next: ptr::null(),
            image: Image::default(),
            old_layout: ImageLayout::default(),
            new_layout: ImageLayout::default(),
            subresource_range: ImageSubresourceRange::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkIOSSurfaceCreateInfoMVK.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct IOSSurfaceCreateInfoMVK {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: IOSSurfaceCreateFlagsMVK,
    pub view: *const c_void,
}

impl Default for IOSSurfaceCreateInfoMVK {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IOS_SURFACE_CREATE_INFO_MVK,
            next: ptr::null(),
            flags: IOSSurfaceCreateFlagsMVK::default(),
            view: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageAlignmentControlCreateInfoMESA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageAlignmentControlCreateInfoMESA {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub maximum_requested_alignment: u32,
}

impl Default for ImageAlignmentControlCreateInfoMESA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA,
            next: ptr::null(),
            maximum_requested_alignment: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageBlit.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ImageBlit {
    pub src_subresource: ImageSubresourceLayers,
    pub src_offsets: [Offset3D; 2],
    pub dst_subresource: ImageSubresourceLayers,
    pub dst_offsets: [Offset3D; 2],
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageBlit2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageBlit2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_subresource: ImageSubresourceLayers,
    pub src_offsets: [Offset3D; 2],
    pub dst_subresource: ImageSubresourceLayers,
    pub dst_offsets: [Offset3D; 2],
}

impl Default for ImageBlit2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_BLIT_2,
            next: ptr::null(),
            src_subresource: ImageSubresourceLayers::default(),
            src_offsets: [Offset3D::default(); 2],
            dst_subresource: ImageSubresourceLayers::default(),
            dst_offsets: [Offset3D::default(); 2],
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageCaptureDescriptorDataInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageCaptureDescriptorDataInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub image: Image,
}

impl Default for ImageCaptureDescriptorDataInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT,
            next: ptr::null(),
            image: Image::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageCompressionControlEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageCompressionControlEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: ImageCompressionFlagsEXT,
    pub compression_control_plane_count: u32,
    pub fixed_rate_flags: *mut ImageCompressionFixedRateFlagsEXT,
}

impl Default for ImageCompressionControlEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_COMPRESSION_CONTROL_EXT,
            next: ptr::null(),
            flags: ImageCompressionFlagsEXT::default(),
            compression_control_plane_count: u32::default(),
            fixed_rate_flags: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageCompressionPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageCompressionPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub image_compression_flags: ImageCompressionFlagsEXT,
    pub image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT,
}

impl Default for ImageCompressionPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_COMPRESSION_PROPERTIES_EXT,
            next: ptr::null_mut(),
            image_compression_flags: ImageCompressionFlagsEXT::default(),
            image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageConstraintsInfoFUCHSIA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageConstraintsInfoFUCHSIA {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub format_constraints_count: u32,
    pub format_constraints: *const ImageFormatConstraintsInfoFUCHSIA,
    pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
    pub flags: ImageConstraintsInfoFlagsFUCHSIA,
}

impl Default for ImageConstraintsInfoFUCHSIA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_CONSTRAINTS_INFO_FUCHSIA,
            next: ptr::null(),
            format_constraints_count: u32::default(),
            format_constraints: ptr::null(),
            buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(),
            flags: ImageConstraintsInfoFlagsFUCHSIA::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageCopy.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ImageCopy {
    pub src_subresource: ImageSubresourceLayers,
    pub src_offset: Offset3D,
    pub dst_subresource: ImageSubresourceLayers,
    pub dst_offset: Offset3D,
    pub extent: Extent3D,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageCopy2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageCopy2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_subresource: ImageSubresourceLayers,
    pub src_offset: Offset3D,
    pub dst_subresource: ImageSubresourceLayers,
    pub dst_offset: Offset3D,
    pub extent: Extent3D,
}

impl Default for ImageCopy2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_COPY_2,
            next: ptr::null(),
            src_subresource: ImageSubresourceLayers::default(),
            src_offset: Offset3D::default(),
            dst_subresource: ImageSubresourceLayers::default(),
            dst_offset: Offset3D::default(),
            extent: Extent3D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: ImageCreateFlags,
    pub image_type: ImageType,
    pub format: Format,
    pub extent: Extent3D,
    pub mip_levels: u32,
    pub array_layers: u32,
    pub samples: SampleCountFlags,
    pub tiling: ImageTiling,
    pub usage: ImageUsageFlags,
    pub sharing_mode: SharingMode,
    pub queue_family_index_count: u32,
    pub queue_family_indices: *const u32,
    pub initial_layout: ImageLayout,
}

impl Default for ImageCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_CREATE_INFO,
            next: ptr::null(),
            flags: ImageCreateFlags::default(),
            image_type: ImageType::default(),
            format: Format::default(),
            extent: Extent3D::default(),
            mip_levels: u32::default(),
            array_layers: u32::default(),
            samples: SampleCountFlags::default(),
            tiling: ImageTiling::default(),
            usage: ImageUsageFlags::default(),
            sharing_mode: SharingMode::default(),
            queue_family_index_count: u32::default(),
            queue_family_indices: ptr::null(),
            initial_layout: ImageLayout::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageDrmFormatModifierExplicitCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageDrmFormatModifierExplicitCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub drm_format_modifier: u64,
    pub drm_format_modifier_plane_count: u32,
    pub plane_layouts: *const SubresourceLayout,
}

impl Default for ImageDrmFormatModifierExplicitCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT,
            next: ptr::null(),
            drm_format_modifier: u64::default(),
            drm_format_modifier_plane_count: u32::default(),
            plane_layouts: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageDrmFormatModifierListCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageDrmFormatModifierListCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub drm_format_modifier_count: u32,
    pub drm_format_modifiers: *const u64,
}

impl Default for ImageDrmFormatModifierListCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT,
            next: ptr::null(),
            drm_format_modifier_count: u32::default(),
            drm_format_modifiers: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageDrmFormatModifierPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageDrmFormatModifierPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub drm_format_modifier: u64,
}

impl Default for ImageDrmFormatModifierPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT,
            next: ptr::null_mut(),
            drm_format_modifier: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageFormatConstraintsInfoFUCHSIA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageFormatConstraintsInfoFUCHSIA {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub image_create_info: ImageCreateInfo,
    pub required_format_features: FormatFeatureFlags,
    pub flags: ImageFormatConstraintsFlagsFUCHSIA,
    pub sysmem_pixel_format: u64,
    pub color_space_count: u32,
    pub color_spaces: *const SysmemColorSpaceFUCHSIA,
}

impl Default for ImageFormatConstraintsInfoFUCHSIA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA,
            next: ptr::null(),
            image_create_info: ImageCreateInfo::default(),
            required_format_features: FormatFeatureFlags::default(),
            flags: ImageFormatConstraintsFlagsFUCHSIA::default(),
            sysmem_pixel_format: u64::default(),
            color_space_count: u32::default(),
            color_spaces: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageFormatListCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageFormatListCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub view_format_count: u32,
    pub view_formats: *const Format,
}

impl Default for ImageFormatListCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_FORMAT_LIST_CREATE_INFO,
            next: ptr::null(),
            view_format_count: u32::default(),
            view_formats: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageFormatProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ImageFormatProperties {
    pub max_extent: Extent3D,
    pub max_mip_levels: u32,
    pub max_array_layers: u32,
    pub sample_counts: SampleCountFlags,
    pub max_resource_size: DeviceSize,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageFormatProperties2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageFormatProperties2 {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub image_format_properties: ImageFormatProperties,
}

impl Default for ImageFormatProperties2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_FORMAT_PROPERTIES_2,
            next: ptr::null_mut(),
            image_format_properties: ImageFormatProperties::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageMemoryBarrier.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageMemoryBarrier {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_access_mask: AccessFlags,
    pub dst_access_mask: AccessFlags,
    pub old_layout: ImageLayout,
    pub new_layout: ImageLayout,
    pub src_queue_family_index: u32,
    pub dst_queue_family_index: u32,
    pub image: Image,
    pub subresource_range: ImageSubresourceRange,
}

impl Default for ImageMemoryBarrier {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_MEMORY_BARRIER,
            next: ptr::null(),
            src_access_mask: AccessFlags::default(),
            dst_access_mask: AccessFlags::default(),
            old_layout: ImageLayout::default(),
            new_layout: ImageLayout::default(),
            src_queue_family_index: u32::default(),
            dst_queue_family_index: u32::default(),
            image: Image::default(),
            subresource_range: ImageSubresourceRange::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageMemoryBarrier2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageMemoryBarrier2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_stage_mask: PipelineStageFlags2,
    pub src_access_mask: AccessFlags2,
    pub dst_stage_mask: PipelineStageFlags2,
    pub dst_access_mask: AccessFlags2,
    pub old_layout: ImageLayout,
    pub new_layout: ImageLayout,
    pub src_queue_family_index: u32,
    pub dst_queue_family_index: u32,
    pub image: Image,
    pub subresource_range: ImageSubresourceRange,
}

impl Default for ImageMemoryBarrier2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_MEMORY_BARRIER_2,
            next: ptr::null(),
            src_stage_mask: PipelineStageFlags2::default(),
            src_access_mask: AccessFlags2::default(),
            dst_stage_mask: PipelineStageFlags2::default(),
            dst_access_mask: AccessFlags2::default(),
            old_layout: ImageLayout::default(),
            new_layout: ImageLayout::default(),
            src_queue_family_index: u32::default(),
            dst_queue_family_index: u32::default(),
            image: Image::default(),
            subresource_range: ImageSubresourceRange::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageMemoryRequirementsInfo2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageMemoryRequirementsInfo2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub image: Image,
}

impl Default for ImageMemoryRequirementsInfo2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_MEMORY_REQUIREMENTS_INFO_2,
            next: ptr::null(),
            image: Image::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImagePipeSurfaceCreateInfoFUCHSIA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImagePipeSurfaceCreateInfoFUCHSIA {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: ImagePipeSurfaceCreateFlagsFUCHSIA,
    pub image_pipe_handle: zx_handle_t,
}

impl Default for ImagePipeSurfaceCreateInfoFUCHSIA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA,
            next: ptr::null(),
            flags: ImagePipeSurfaceCreateFlagsFUCHSIA::default(),
            image_pipe_handle: zx_handle_t::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImagePlaneMemoryRequirementsInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImagePlaneMemoryRequirementsInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub plane_aspect: ImageAspectFlags,
}

impl Default for ImagePlaneMemoryRequirementsInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
            next: ptr::null(),
            plane_aspect: ImageAspectFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageResolve.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ImageResolve {
    pub src_subresource: ImageSubresourceLayers,
    pub src_offset: Offset3D,
    pub dst_subresource: ImageSubresourceLayers,
    pub dst_offset: Offset3D,
    pub extent: Extent3D,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageResolve2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageResolve2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_subresource: ImageSubresourceLayers,
    pub src_offset: Offset3D,
    pub dst_subresource: ImageSubresourceLayers,
    pub dst_offset: Offset3D,
    pub extent: Extent3D,
}

impl Default for ImageResolve2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_RESOLVE_2,
            next: ptr::null(),
            src_subresource: ImageSubresourceLayers::default(),
            src_offset: Offset3D::default(),
            dst_subresource: ImageSubresourceLayers::default(),
            dst_offset: Offset3D::default(),
            extent: Extent3D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageSparseMemoryRequirementsInfo2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageSparseMemoryRequirementsInfo2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub image: Image,
}

impl Default for ImageSparseMemoryRequirementsInfo2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
            next: ptr::null(),
            image: Image::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageStencilUsageCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageStencilUsageCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub stencil_usage: ImageUsageFlags,
}

impl Default for ImageStencilUsageCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_STENCIL_USAGE_CREATE_INFO,
            next: ptr::null(),
            stencil_usage: ImageUsageFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageSubresource.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ImageSubresource {
    pub aspect_mask: ImageAspectFlags,
    pub mip_level: u32,
    pub array_layer: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageSubresource2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageSubresource2 {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub image_subresource: ImageSubresource,
}

impl Default for ImageSubresource2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_SUBRESOURCE_2,
            next: ptr::null_mut(),
            image_subresource: ImageSubresource::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageSubresourceLayers.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ImageSubresourceLayers {
    pub aspect_mask: ImageAspectFlags,
    pub mip_level: u32,
    pub base_array_layer: u32,
    pub layer_count: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageSubresourceRange.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ImageSubresourceRange {
    pub aspect_mask: ImageAspectFlags,
    pub base_mip_level: u32,
    pub level_count: u32,
    pub base_array_layer: u32,
    pub layer_count: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageSwapchainCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageSwapchainCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub swapchain: SwapchainKHR,
}

impl Default for ImageSwapchainCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_SWAPCHAIN_CREATE_INFO_KHR,
            next: ptr::null(),
            swapchain: SwapchainKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageToMemoryCopy.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageToMemoryCopy {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub host_pointer: *mut c_void,
    pub memory_row_length: u32,
    pub memory_image_height: u32,
    pub image_subresource: ImageSubresourceLayers,
    pub image_offset: Offset3D,
    pub image_extent: Extent3D,
}

impl Default for ImageToMemoryCopy {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_TO_MEMORY_COPY,
            next: ptr::null(),
            host_pointer: ptr::null_mut(),
            memory_row_length: u32::default(),
            memory_image_height: u32::default(),
            image_subresource: ImageSubresourceLayers::default(),
            image_offset: Offset3D::default(),
            image_extent: Extent3D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageViewASTCDecodeModeEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageViewASTCDecodeModeEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub decode_mode: Format,
}

impl Default for ImageViewASTCDecodeModeEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_VIEW_ASTC_DECODE_MODE_EXT,
            next: ptr::null(),
            decode_mode: Format::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageViewAddressPropertiesNVX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageViewAddressPropertiesNVX {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub device_address: DeviceAddress,
    pub size: DeviceSize,
}

impl Default for ImageViewAddressPropertiesNVX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX,
            next: ptr::null_mut(),
            device_address: DeviceAddress::default(),
            size: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageViewCaptureDescriptorDataInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageViewCaptureDescriptorDataInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub image_view: ImageView,
}

impl Default for ImageViewCaptureDescriptorDataInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT,
            next: ptr::null(),
            image_view: ImageView::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageViewCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageViewCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: ImageViewCreateFlags,
    pub image: Image,
    pub view_type: ImageViewType,
    pub format: Format,
    pub components: ComponentMapping,
    pub subresource_range: ImageSubresourceRange,
}

impl Default for ImageViewCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_VIEW_CREATE_INFO,
            next: ptr::null(),
            flags: ImageViewCreateFlags::default(),
            image: Image::default(),
            view_type: ImageViewType::default(),
            format: Format::default(),
            components: ComponentMapping::default(),
            subresource_range: ImageSubresourceRange::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageViewHandleInfoNVX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageViewHandleInfoNVX {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub image_view: ImageView,
    pub descriptor_type: DescriptorType,
    pub sampler: Sampler,
}

impl Default for ImageViewHandleInfoNVX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_VIEW_HANDLE_INFO_NVX,
            next: ptr::null(),
            image_view: ImageView::default(),
            descriptor_type: DescriptorType::default(),
            sampler: Sampler::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageViewMinLodCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct ImageViewMinLodCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub min_lod: f32,
}

impl Default for ImageViewMinLodCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT,
            next: ptr::null(),
            min_lod: f32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageViewSampleWeightCreateInfoQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageViewSampleWeightCreateInfoQCOM {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub filter_center: Offset2D,
    pub filter_size: Extent2D,
    pub num_phases: u32,
}

impl Default for ImageViewSampleWeightCreateInfoQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM,
            next: ptr::null(),
            filter_center: Offset2D::default(),
            filter_size: Extent2D::default(),
            num_phases: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageViewSlicedCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageViewSlicedCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub slice_offset: u32,
    pub slice_count: u32,
}

impl Default for ImageViewSlicedCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_VIEW_SLICED_CREATE_INFO_EXT,
            next: ptr::null(),
            slice_offset: u32::default(),
            slice_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageViewUsageCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImageViewUsageCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub usage: ImageUsageFlags,
}

impl Default for ImageViewUsageCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMAGE_VIEW_USAGE_CREATE_INFO,
            next: ptr::null(),
            usage: ImageUsageFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportAndroidHardwareBufferInfoANDROID.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportAndroidHardwareBufferInfoANDROID {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub buffer: *mut AHardwareBuffer,
}

impl Default for ImportAndroidHardwareBufferInfoANDROID {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
            next: ptr::null(),
            buffer: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportFenceFdInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportFenceFdInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub fence: Fence,
    pub flags: FenceImportFlags,
    pub handle_type: ExternalFenceHandleTypeFlags,
    pub fd: c_int,
}

impl Default for ImportFenceFdInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_FENCE_FD_INFO_KHR,
            next: ptr::null(),
            fence: Fence::default(),
            flags: FenceImportFlags::default(),
            handle_type: ExternalFenceHandleTypeFlags::default(),
            fd: c_int::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportFenceSciSyncInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportFenceSciSyncInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub fence: Fence,
    pub handle_type: ExternalFenceHandleTypeFlags,
    pub handle: *mut c_void,
}

impl Default for ImportFenceSciSyncInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_FENCE_SCI_SYNC_INFO_NV,
            next: ptr::null(),
            fence: Fence::default(),
            handle_type: ExternalFenceHandleTypeFlags::default(),
            handle: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportFenceWin32HandleInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportFenceWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub fence: Fence,
    pub flags: FenceImportFlags,
    pub handle_type: ExternalFenceHandleTypeFlags,
    pub handle: HANDLE,
    pub name: LPCWSTR,
}

impl Default for ImportFenceWin32HandleInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR,
            next: ptr::null(),
            fence: Fence::default(),
            flags: FenceImportFlags::default(),
            handle_type: ExternalFenceHandleTypeFlags::default(),
            handle: ptr::null_mut(),
            name: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportMemoryBufferCollectionFUCHSIA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportMemoryBufferCollectionFUCHSIA {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub collection: BufferCollectionFUCHSIA,
    pub index: u32,
}

impl Default for ImportMemoryBufferCollectionFUCHSIA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA,
            next: ptr::null(),
            collection: BufferCollectionFUCHSIA::default(),
            index: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportMemoryFdInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportMemoryFdInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub fd: c_int,
}

impl Default for ImportMemoryFdInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_MEMORY_FD_INFO_KHR,
            next: ptr::null(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
            fd: c_int::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportMemoryHostPointerInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportMemoryHostPointerInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub host_pointer: *mut c_void,
}

impl Default for ImportMemoryHostPointerInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
            next: ptr::null(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
            host_pointer: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportMemoryMetalHandleInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportMemoryMetalHandleInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub handle: *mut c_void,
}

impl Default for ImportMemoryMetalHandleInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_MEMORY_METAL_HANDLE_INFO_EXT,
            next: ptr::null(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
            handle: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportMemorySciBufInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportMemorySciBufInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub handle: NvSciBufObj,
}

impl Default for ImportMemorySciBufInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_MEMORY_SCI_BUF_INFO_NV,
            next: ptr::null(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
            handle: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportMemoryWin32HandleInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportMemoryWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub handle: HANDLE,
    pub name: LPCWSTR,
}

impl Default for ImportMemoryWin32HandleInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
            next: ptr::null(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
            handle: ptr::null_mut(),
            name: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportMemoryWin32HandleInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportMemoryWin32HandleInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlagsNV,
    pub handle: HANDLE,
}

impl Default for ImportMemoryWin32HandleInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
            next: ptr::null(),
            handle_type: ExternalMemoryHandleTypeFlagsNV::default(),
            handle: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportMemoryZirconHandleInfoFUCHSIA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportMemoryZirconHandleInfoFUCHSIA {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub handle: zx_handle_t,
}

impl Default for ImportMemoryZirconHandleInfoFUCHSIA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA,
            next: ptr::null(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
            handle: zx_handle_t::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportMetalBufferInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportMetalBufferInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub mtl_buffer: MTLBuffer_id,
}

impl Default for ImportMetalBufferInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_METAL_BUFFER_INFO_EXT,
            next: ptr::null(),
            mtl_buffer: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportMetalIOSurfaceInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportMetalIOSurfaceInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub io_surface: IOSurfaceRef,
}

impl Default for ImportMetalIOSurfaceInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_METAL_IO_SURFACE_INFO_EXT,
            next: ptr::null(),
            io_surface: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportMetalSharedEventInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportMetalSharedEventInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub mtl_shared_event: MTLSharedEvent_id,
}

impl Default for ImportMetalSharedEventInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_METAL_SHARED_EVENT_INFO_EXT,
            next: ptr::null(),
            mtl_shared_event: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportMetalTextureInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportMetalTextureInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub plane: ImageAspectFlags,
    pub mtl_texture: MTLTexture_id,
}

impl Default for ImportMetalTextureInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_METAL_TEXTURE_INFO_EXT,
            next: ptr::null(),
            plane: ImageAspectFlags::default(),
            mtl_texture: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportScreenBufferInfoQNX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportScreenBufferInfoQNX {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub buffer: *mut _screen_buffer,
}

impl Default for ImportScreenBufferInfoQNX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_SCREEN_BUFFER_INFO_QNX,
            next: ptr::null(),
            buffer: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportSemaphoreFdInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportSemaphoreFdInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub flags: SemaphoreImportFlags,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
    pub fd: c_int,
}

impl Default for ImportSemaphoreFdInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_SEMAPHORE_FD_INFO_KHR,
            next: ptr::null(),
            semaphore: Semaphore::default(),
            flags: SemaphoreImportFlags::default(),
            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
            fd: c_int::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportSemaphoreSciSyncInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportSemaphoreSciSyncInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
    pub handle: *mut c_void,
}

impl Default for ImportSemaphoreSciSyncInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_SEMAPHORE_SCI_SYNC_INFO_NV,
            next: ptr::null(),
            semaphore: Semaphore::default(),
            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
            handle: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportSemaphoreWin32HandleInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportSemaphoreWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub flags: SemaphoreImportFlags,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
    pub handle: HANDLE,
    pub name: LPCWSTR,
}

impl Default for ImportSemaphoreWin32HandleInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
            next: ptr::null(),
            semaphore: Semaphore::default(),
            flags: SemaphoreImportFlags::default(),
            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
            handle: ptr::null_mut(),
            name: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImportSemaphoreZirconHandleInfoFUCHSIA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ImportSemaphoreZirconHandleInfoFUCHSIA {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub flags: SemaphoreImportFlags,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
    pub zircon_handle: zx_handle_t,
}

impl Default for ImportSemaphoreZirconHandleInfoFUCHSIA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA,
            next: ptr::null(),
            semaphore: Semaphore::default(),
            flags: SemaphoreImportFlags::default(),
            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
            zircon_handle: zx_handle_t::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkIndirectCommandsExecutionSetTokenEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct IndirectCommandsExecutionSetTokenEXT {
    pub type_: IndirectExecutionSetInfoTypeEXT,
    pub shader_stages: ShaderStageFlags,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkIndirectCommandsIndexBufferTokenEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct IndirectCommandsIndexBufferTokenEXT {
    pub mode: IndirectCommandsInputModeFlagsEXT,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct IndirectCommandsLayoutCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: IndirectCommandsLayoutUsageFlagsEXT,
    pub shader_stages: ShaderStageFlags,
    pub indirect_stride: u32,
    pub pipeline_layout: PipelineLayout,
    pub token_count: u32,
    pub tokens: *const IndirectCommandsLayoutTokenEXT,
}

impl Default for IndirectCommandsLayoutCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT,
            next: ptr::null(),
            flags: IndirectCommandsLayoutUsageFlagsEXT::default(),
            shader_stages: ShaderStageFlags::default(),
            indirect_stride: u32::default(),
            pipeline_layout: PipelineLayout::default(),
            token_count: u32::default(),
            tokens: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct IndirectCommandsLayoutCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: IndirectCommandsLayoutUsageFlagsNV,
    pub pipeline_bind_point: PipelineBindPoint,
    pub token_count: u32,
    pub tokens: *const IndirectCommandsLayoutTokenNV,
    pub stream_count: u32,
    pub stream_strides: *const u32,
}

impl Default for IndirectCommandsLayoutCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV,
            next: ptr::null(),
            flags: IndirectCommandsLayoutUsageFlagsNV::default(),
            pipeline_bind_point: PipelineBindPoint::default(),
            token_count: u32::default(),
            tokens: ptr::null(),
            stream_count: u32::default(),
            stream_strides: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutTokenEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IndirectCommandsLayoutTokenEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub type_: IndirectCommandsTokenTypeEXT,
    pub data: IndirectCommandsTokenDataEXT,
    pub offset: u32,
}

impl Default for IndirectCommandsLayoutTokenEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT,
            next: ptr::null(),
            type_: IndirectCommandsTokenTypeEXT::default(),
            data: IndirectCommandsTokenDataEXT::default(),
            offset: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutTokenNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct IndirectCommandsLayoutTokenNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub token_type: IndirectCommandsTokenTypeNV,
    pub stream: u32,
    pub offset: u32,
    pub vertex_binding_unit: u32,
    pub vertex_dynamic_stride: Bool32,
    pub pushconstant_pipeline_layout: PipelineLayout,
    pub pushconstant_shader_stage_flags: ShaderStageFlags,
    pub pushconstant_offset: u32,
    pub pushconstant_size: u32,
    pub indirect_state_flags: IndirectStateFlagsNV,
    pub index_type_count: u32,
    pub index_types: *const IndexType,
    pub index_type_values: *const u32,
}

impl Default for IndirectCommandsLayoutTokenNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV,
            next: ptr::null(),
            token_type: IndirectCommandsTokenTypeNV::default(),
            stream: u32::default(),
            offset: u32::default(),
            vertex_binding_unit: u32::default(),
            vertex_dynamic_stride: Bool32::default(),
            pushconstant_pipeline_layout: PipelineLayout::default(),
            pushconstant_shader_stage_flags: ShaderStageFlags::default(),
            pushconstant_offset: u32::default(),
            pushconstant_size: u32::default(),
            indirect_state_flags: IndirectStateFlagsNV::default(),
            index_type_count: u32::default(),
            index_types: ptr::null(),
            index_type_values: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkIndirectCommandsPushConstantTokenEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct IndirectCommandsPushConstantTokenEXT {
    pub update_range: PushConstantRange,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkIndirectCommandsStreamNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct IndirectCommandsStreamNV {
    pub buffer: Buffer,
    pub offset: DeviceSize,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkIndirectCommandsVertexBufferTokenEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct IndirectCommandsVertexBufferTokenEXT {
    pub vertex_binding_unit: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkIndirectExecutionSetCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IndirectExecutionSetCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub type_: IndirectExecutionSetInfoTypeEXT,
    pub info: IndirectExecutionSetInfoEXT,
}

impl Default for IndirectExecutionSetCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::INDIRECT_EXECUTION_SET_CREATE_INFO_EXT,
            next: ptr::null(),
            type_: IndirectExecutionSetInfoTypeEXT::default(),
            info: IndirectExecutionSetInfoEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkIndirectExecutionSetPipelineInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct IndirectExecutionSetPipelineInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub initial_pipeline: Pipeline,
    pub max_pipeline_count: u32,
}

impl Default for IndirectExecutionSetPipelineInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT,
            next: ptr::null(),
            initial_pipeline: Pipeline::default(),
            max_pipeline_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkIndirectExecutionSetShaderInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct IndirectExecutionSetShaderInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub shader_count: u32,
    pub initial_shaders: *const ShaderEXT,
    pub set_layout_infos: *const IndirectExecutionSetShaderLayoutInfoEXT,
    pub max_shader_count: u32,
    pub push_constant_range_count: u32,
    pub push_constant_ranges: *const PushConstantRange,
}

impl Default for IndirectExecutionSetShaderInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::INDIRECT_EXECUTION_SET_SHADER_INFO_EXT,
            next: ptr::null(),
            shader_count: u32::default(),
            initial_shaders: ptr::null(),
            set_layout_infos: ptr::null(),
            max_shader_count: u32::default(),
            push_constant_range_count: u32::default(),
            push_constant_ranges: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkIndirectExecutionSetShaderLayoutInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct IndirectExecutionSetShaderLayoutInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub set_layout_count: u32,
    pub set_layouts: *const DescriptorSetLayout,
}

impl Default for IndirectExecutionSetShaderLayoutInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT,
            next: ptr::null(),
            set_layout_count: u32::default(),
            set_layouts: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkInitializePerformanceApiInfoINTEL.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct InitializePerformanceApiInfoINTEL {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub user_data: *mut c_void,
}

impl Default for InitializePerformanceApiInfoINTEL {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::INITIALIZE_PERFORMANCE_API_INFO_INTEL,
            next: ptr::null(),
            user_data: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkInputAttachmentAspectReference.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct InputAttachmentAspectReference {
    pub subpass: u32,
    pub input_attachment_index: u32,
    pub aspect_mask: ImageAspectFlags,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkInstanceCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct InstanceCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: InstanceCreateFlags,
    pub application_info: *const ApplicationInfo,
    pub enabled_layer_count: u32,
    pub enabled_layer_names: *const *const c_char,
    pub enabled_extension_count: u32,
    pub enabled_extension_names: *const *const c_char,
}

impl Default for InstanceCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::INSTANCE_CREATE_INFO,
            next: ptr::null(),
            flags: InstanceCreateFlags::default(),
            application_info: ptr::null(),
            enabled_layer_count: u32::default(),
            enabled_layer_names: ptr::null(),
            enabled_extension_count: u32::default(),
            enabled_extension_names: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkLatencySleepInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct LatencySleepInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub signal_semaphore: Semaphore,
    pub value: u64,
}

impl Default for LatencySleepInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::LATENCY_SLEEP_INFO_NV,
            next: ptr::null(),
            signal_semaphore: Semaphore::default(),
            value: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkLatencySleepModeInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct LatencySleepModeInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub low_latency_mode: Bool32,
    pub low_latency_boost: Bool32,
    pub minimum_interval_us: u32,
}

impl Default for LatencySleepModeInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::LATENCY_SLEEP_MODE_INFO_NV,
            next: ptr::null(),
            low_latency_mode: Bool32::default(),
            low_latency_boost: Bool32::default(),
            minimum_interval_us: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkLatencySubmissionPresentIdNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct LatencySubmissionPresentIdNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub present_id: u64,
}

impl Default for LatencySubmissionPresentIdNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::LATENCY_SUBMISSION_PRESENT_ID_NV,
            next: ptr::null(),
            present_id: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkLatencySurfaceCapabilitiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct LatencySurfaceCapabilitiesNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub present_mode_count: u32,
    pub present_modes: *mut PresentModeKHR,
}

impl Default for LatencySurfaceCapabilitiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::LATENCY_SURFACE_CAPABILITIES_NV,
            next: ptr::null(),
            present_mode_count: u32::default(),
            present_modes: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkLatencyTimingsFrameReportNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct LatencyTimingsFrameReportNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub present_id: u64,
    pub input_sample_time_us: u64,
    pub sim_start_time_us: u64,
    pub sim_end_time_us: u64,
    pub render_submit_start_time_us: u64,
    pub render_submit_end_time_us: u64,
    pub present_start_time_us: u64,
    pub present_end_time_us: u64,
    pub driver_start_time_us: u64,
    pub driver_end_time_us: u64,
    pub os_render_queue_start_time_us: u64,
    pub os_render_queue_end_time_us: u64,
    pub gpu_render_start_time_us: u64,
    pub gpu_render_end_time_us: u64,
}

impl Default for LatencyTimingsFrameReportNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::LATENCY_TIMINGS_FRAME_REPORT_NV,
            next: ptr::null(),
            present_id: u64::default(),
            input_sample_time_us: u64::default(),
            sim_start_time_us: u64::default(),
            sim_end_time_us: u64::default(),
            render_submit_start_time_us: u64::default(),
            render_submit_end_time_us: u64::default(),
            present_start_time_us: u64::default(),
            present_end_time_us: u64::default(),
            driver_start_time_us: u64::default(),
            driver_end_time_us: u64::default(),
            os_render_queue_start_time_us: u64::default(),
            os_render_queue_end_time_us: u64::default(),
            gpu_render_start_time_us: u64::default(),
            gpu_render_end_time_us: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkLayerProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct LayerProperties {
    pub layer_name: StringArray<MAX_EXTENSION_NAME_SIZE>,
    pub spec_version: u32,
    pub implementation_version: u32,
    pub description: StringArray<MAX_DESCRIPTION_SIZE>,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkLayerSettingEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct LayerSettingEXT {
    pub layer_name: *const c_char,
    pub setting_name: *const c_char,
    pub type_: LayerSettingTypeEXT,
    pub value_count: u32,
    pub values: *const c_void,
}

impl Default for LayerSettingEXT {
    #[inline]
    fn default() -> Self {
        Self {
            layer_name: ptr::null(),
            setting_name: ptr::null(),
            type_: LayerSettingTypeEXT::default(),
            value_count: u32::default(),
            values: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkLayerSettingsCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct LayerSettingsCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub setting_count: u32,
    pub settings: *const LayerSettingEXT,
}

impl Default for LayerSettingsCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::LAYER_SETTINGS_CREATE_INFO_EXT,
            next: ptr::null(),
            setting_count: u32::default(),
            settings: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMacOSSurfaceCreateInfoMVK.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MacOSSurfaceCreateInfoMVK {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: MacOSSurfaceCreateFlagsMVK,
    pub view: *const c_void,
}

impl Default for MacOSSurfaceCreateInfoMVK {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MACOS_SURFACE_CREATE_INFO_MVK,
            next: ptr::null(),
            flags: MacOSSurfaceCreateFlagsMVK::default(),
            view: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMappedMemoryRange.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MappedMemoryRange {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub offset: DeviceSize,
    pub size: DeviceSize,
}

impl Default for MappedMemoryRange {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MAPPED_MEMORY_RANGE,
            next: ptr::null(),
            memory: DeviceMemory::default(),
            offset: DeviceSize::default(),
            size: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryAllocateFlagsInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryAllocateFlagsInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: MemoryAllocateFlags,
    pub device_mask: u32,
}

impl Default for MemoryAllocateFlagsInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_ALLOCATE_FLAGS_INFO,
            next: ptr::null(),
            flags: MemoryAllocateFlags::default(),
            device_mask: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryAllocateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryAllocateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub allocation_size: DeviceSize,
    pub memory_type_index: u32,
}

impl Default for MemoryAllocateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_ALLOCATE_INFO,
            next: ptr::null(),
            allocation_size: DeviceSize::default(),
            memory_type_index: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryBarrier.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryBarrier {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_access_mask: AccessFlags,
    pub dst_access_mask: AccessFlags,
}

impl Default for MemoryBarrier {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_BARRIER,
            next: ptr::null(),
            src_access_mask: AccessFlags::default(),
            dst_access_mask: AccessFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryBarrier2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryBarrier2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_stage_mask: PipelineStageFlags2,
    pub src_access_mask: AccessFlags2,
    pub dst_stage_mask: PipelineStageFlags2,
    pub dst_access_mask: AccessFlags2,
}

impl Default for MemoryBarrier2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_BARRIER_2,
            next: ptr::null(),
            src_stage_mask: PipelineStageFlags2::default(),
            src_access_mask: AccessFlags2::default(),
            dst_stage_mask: PipelineStageFlags2::default(),
            dst_access_mask: AccessFlags2::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryBarrierAccessFlags3KHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryBarrierAccessFlags3KHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_access_mask3: AccessFlags3KHR,
    pub dst_access_mask3: AccessFlags3KHR,
}

impl Default for MemoryBarrierAccessFlags3KHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_BARRIER_ACCESS_FLAGS_3_KHR,
            next: ptr::null(),
            src_access_mask3: AccessFlags3KHR::default(),
            dst_access_mask3: AccessFlags3KHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryDedicatedAllocateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryDedicatedAllocateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub image: Image,
    pub buffer: Buffer,
}

impl Default for MemoryDedicatedAllocateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_DEDICATED_ALLOCATE_INFO,
            next: ptr::null(),
            image: Image::default(),
            buffer: Buffer::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryDedicatedRequirements.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryDedicatedRequirements {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub prefers_dedicated_allocation: Bool32,
    pub requires_dedicated_allocation: Bool32,
}

impl Default for MemoryDedicatedRequirements {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_DEDICATED_REQUIREMENTS,
            next: ptr::null_mut(),
            prefers_dedicated_allocation: Bool32::default(),
            requires_dedicated_allocation: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryFdPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryFdPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub memory_type_bits: u32,
}

impl Default for MemoryFdPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_FD_PROPERTIES_KHR,
            next: ptr::null_mut(),
            memory_type_bits: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryGetAndroidHardwareBufferInfoANDROID.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryGetAndroidHardwareBufferInfoANDROID {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub memory: DeviceMemory,
}

impl Default for MemoryGetAndroidHardwareBufferInfoANDROID {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
            next: ptr::null(),
            memory: DeviceMemory::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryGetFdInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryGetFdInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub handle_type: ExternalMemoryHandleTypeFlags,
}

impl Default for MemoryGetFdInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_GET_FD_INFO_KHR,
            next: ptr::null(),
            memory: DeviceMemory::default(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryGetMetalHandleInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryGetMetalHandleInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub handle_type: ExternalMemoryHandleTypeFlags,
}

impl Default for MemoryGetMetalHandleInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_GET_METAL_HANDLE_INFO_EXT,
            next: ptr::null(),
            memory: DeviceMemory::default(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryGetRemoteAddressInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryGetRemoteAddressInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub handle_type: ExternalMemoryHandleTypeFlags,
}

impl Default for MemoryGetRemoteAddressInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_GET_REMOTE_ADDRESS_INFO_NV,
            next: ptr::null(),
            memory: DeviceMemory::default(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryGetSciBufInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryGetSciBufInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub handle_type: ExternalMemoryHandleTypeFlags,
}

impl Default for MemoryGetSciBufInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_GET_SCI_BUF_INFO_NV,
            next: ptr::null(),
            memory: DeviceMemory::default(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryGetWin32HandleInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryGetWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub handle_type: ExternalMemoryHandleTypeFlags,
}

impl Default for MemoryGetWin32HandleInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_GET_WIN32_HANDLE_INFO_KHR,
            next: ptr::null(),
            memory: DeviceMemory::default(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryGetZirconHandleInfoFUCHSIA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryGetZirconHandleInfoFUCHSIA {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub handle_type: ExternalMemoryHandleTypeFlags,
}

impl Default for MemoryGetZirconHandleInfoFUCHSIA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA,
            next: ptr::null(),
            memory: DeviceMemory::default(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryHeap.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct MemoryHeap {
    pub size: DeviceSize,
    pub flags: MemoryHeapFlags,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryHostPointerPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryHostPointerPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub memory_type_bits: u32,
}

impl Default for MemoryHostPointerPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_HOST_POINTER_PROPERTIES_EXT,
            next: ptr::null_mut(),
            memory_type_bits: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryMapInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryMapInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: MemoryMapFlags,
    pub memory: DeviceMemory,
    pub offset: DeviceSize,
    pub size: DeviceSize,
}

impl Default for MemoryMapInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_MAP_INFO,
            next: ptr::null(),
            flags: MemoryMapFlags::default(),
            memory: DeviceMemory::default(),
            offset: DeviceSize::default(),
            size: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryMapPlacedInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryMapPlacedInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub placed_address: *mut c_void,
}

impl Default for MemoryMapPlacedInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_MAP_PLACED_INFO_EXT,
            next: ptr::null(),
            placed_address: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryMetalHandlePropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryMetalHandlePropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub memory_type_bits: u32,
}

impl Default for MemoryMetalHandlePropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_METAL_HANDLE_PROPERTIES_EXT,
            next: ptr::null_mut(),
            memory_type_bits: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryOpaqueCaptureAddressAllocateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryOpaqueCaptureAddressAllocateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub opaque_capture_address: u64,
}

impl Default for MemoryOpaqueCaptureAddressAllocateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,
            next: ptr::null(),
            opaque_capture_address: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryPriorityAllocateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct MemoryPriorityAllocateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub priority: f32,
}

impl Default for MemoryPriorityAllocateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_PRIORITY_ALLOCATE_INFO_EXT,
            next: ptr::null(),
            priority: f32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryRequirements.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct MemoryRequirements {
    pub size: DeviceSize,
    pub alignment: DeviceSize,
    pub memory_type_bits: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryRequirements2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryRequirements2 {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub memory_requirements: MemoryRequirements,
}

impl Default for MemoryRequirements2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_REQUIREMENTS_2,
            next: ptr::null_mut(),
            memory_requirements: MemoryRequirements::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemorySciBufPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemorySciBufPropertiesNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub memory_type_bits: u32,
}

impl Default for MemorySciBufPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_SCI_BUF_PROPERTIES_NV,
            next: ptr::null(),
            memory_type_bits: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryToImageCopy.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryToImageCopy {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub host_pointer: *const c_void,
    pub memory_row_length: u32,
    pub memory_image_height: u32,
    pub image_subresource: ImageSubresourceLayers,
    pub image_offset: Offset3D,
    pub image_extent: Extent3D,
}

impl Default for MemoryToImageCopy {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_TO_IMAGE_COPY,
            next: ptr::null(),
            host_pointer: ptr::null(),
            memory_row_length: u32::default(),
            memory_image_height: u32::default(),
            image_subresource: ImageSubresourceLayers::default(),
            image_offset: Offset3D::default(),
            image_extent: Extent3D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryType.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct MemoryType {
    pub property_flags: MemoryPropertyFlags,
    pub heap_index: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryUnmapInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryUnmapInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: MemoryUnmapFlags,
    pub memory: DeviceMemory,
}

impl Default for MemoryUnmapInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_UNMAP_INFO,
            next: ptr::null(),
            flags: MemoryUnmapFlags::default(),
            memory: DeviceMemory::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryWin32HandlePropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryWin32HandlePropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub memory_type_bits: u32,
}

impl Default for MemoryWin32HandlePropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_WIN32_HANDLE_PROPERTIES_KHR,
            next: ptr::null_mut(),
            memory_type_bits: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryZirconHandlePropertiesFUCHSIA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MemoryZirconHandlePropertiesFUCHSIA {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub memory_type_bits: u32,
}

impl Default for MemoryZirconHandlePropertiesFUCHSIA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA,
            next: ptr::null_mut(),
            memory_type_bits: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMetalSurfaceCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MetalSurfaceCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: MetalSurfaceCreateFlagsEXT,
    pub layer: *const CAMetalLayer,
}

impl Default for MetalSurfaceCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::METAL_SURFACE_CREATE_INFO_EXT,
            next: ptr::null(),
            flags: MetalSurfaceCreateFlagsEXT::default(),
            layer: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMicromapBuildInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MicromapBuildInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub type_: MicromapTypeEXT,
    pub flags: BuildMicromapFlagsEXT,
    pub mode: BuildMicromapModeEXT,
    pub dst_micromap: MicromapEXT,
    pub usage_counts_count: u32,
    pub usage_counts: *const MicromapUsageEXT,
    pub pointer_usage_counts: *const *const MicromapUsageEXT,
    pub data: DeviceOrHostAddressConstKHR,
    pub scratch_data: DeviceOrHostAddressKHR,
    pub triangle_array: DeviceOrHostAddressConstKHR,
    pub triangle_array_stride: DeviceSize,
}

impl Default for MicromapBuildInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MICROMAP_BUILD_INFO_EXT,
            next: ptr::null(),
            type_: MicromapTypeEXT::default(),
            flags: BuildMicromapFlagsEXT::default(),
            mode: BuildMicromapModeEXT::default(),
            dst_micromap: MicromapEXT::default(),
            usage_counts_count: u32::default(),
            usage_counts: ptr::null(),
            pointer_usage_counts: ptr::null(),
            data: DeviceOrHostAddressConstKHR::default(),
            scratch_data: DeviceOrHostAddressKHR::default(),
            triangle_array: DeviceOrHostAddressConstKHR::default(),
            triangle_array_stride: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMicromapBuildSizesInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MicromapBuildSizesInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub micromap_size: DeviceSize,
    pub build_scratch_size: DeviceSize,
    pub discardable: Bool32,
}

impl Default for MicromapBuildSizesInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MICROMAP_BUILD_SIZES_INFO_EXT,
            next: ptr::null(),
            micromap_size: DeviceSize::default(),
            build_scratch_size: DeviceSize::default(),
            discardable: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMicromapCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MicromapCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub create_flags: MicromapCreateFlagsEXT,
    pub buffer: Buffer,
    pub offset: DeviceSize,
    pub size: DeviceSize,
    pub type_: MicromapTypeEXT,
    pub device_address: DeviceAddress,
}

impl Default for MicromapCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MICROMAP_CREATE_INFO_EXT,
            next: ptr::null(),
            create_flags: MicromapCreateFlagsEXT::default(),
            buffer: Buffer::default(),
            offset: DeviceSize::default(),
            size: DeviceSize::default(),
            type_: MicromapTypeEXT::default(),
            device_address: DeviceAddress::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMicromapTriangleEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct MicromapTriangleEXT {
    pub data_offset: u32,
    pub subdivision_level: u16,
    pub format: u16,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMicromapUsageEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct MicromapUsageEXT {
    pub count: u32,
    pub subdivision_level: u32,
    pub format: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMicromapVersionInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MicromapVersionInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub version_data: *const u8,
}

impl Default for MicromapVersionInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MICROMAP_VERSION_INFO_EXT,
            next: ptr::null(),
            version_data: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMultiDrawIndexedInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct MultiDrawIndexedInfoEXT {
    pub first_index: u32,
    pub index_count: u32,
    pub vertex_offset: i32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMultiDrawInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct MultiDrawInfoEXT {
    pub first_vertex: u32,
    pub vertex_count: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMultisamplePropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MultisamplePropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_sample_location_grid_size: Extent2D,
}

impl Default for MultisamplePropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MULTISAMPLE_PROPERTIES_EXT,
            next: ptr::null_mut(),
            max_sample_location_grid_size: Extent2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMultisampledRenderToSingleSampledInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MultisampledRenderToSingleSampledInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub multisampled_render_to_single_sampled_enable: Bool32,
    pub rasterization_samples: SampleCountFlags,
}

impl Default for MultisampledRenderToSingleSampledInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT,
            next: ptr::null(),
            multisampled_render_to_single_sampled_enable: Bool32::default(),
            rasterization_samples: SampleCountFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMultiviewPerViewAttributesInfoNVX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MultiviewPerViewAttributesInfoNVX {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub per_view_attributes: Bool32,
    pub per_view_attributes_position_x_only: Bool32,
}

impl Default for MultiviewPerViewAttributesInfoNVX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX,
            next: ptr::null(),
            per_view_attributes: Bool32::default(),
            per_view_attributes_position_x_only: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub per_view_render_area_count: u32,
    pub per_view_render_areas: *const Rect2D,
}

impl Default for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM,
            next: ptr::null(),
            per_view_render_area_count: u32::default(),
            per_view_render_areas: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMutableDescriptorTypeCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MutableDescriptorTypeCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub mutable_descriptor_type_list_count: u32,
    pub mutable_descriptor_type_lists: *const MutableDescriptorTypeListEXT,
}

impl Default for MutableDescriptorTypeCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT,
            next: ptr::null(),
            mutable_descriptor_type_list_count: u32::default(),
            mutable_descriptor_type_lists: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMutableDescriptorTypeListEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct MutableDescriptorTypeListEXT {
    pub descriptor_type_count: u32,
    pub descriptor_types: *const DescriptorType,
}

impl Default for MutableDescriptorTypeListEXT {
    #[inline]
    fn default() -> Self {
        Self {
            descriptor_type_count: u32::default(),
            descriptor_types: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkOffset2D.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct Offset2D {
    pub x: i32,
    pub y: i32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkOffset3D.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct Offset3D {
    pub x: i32,
    pub y: i32,
    pub z: i32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkOpaqueCaptureDescriptorDataCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct OpaqueCaptureDescriptorDataCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub opaque_capture_descriptor_data: *const c_void,
}

impl Default for OpaqueCaptureDescriptorDataCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT,
            next: ptr::null(),
            opaque_capture_descriptor_data: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkOpticalFlowExecuteInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct OpticalFlowExecuteInfoNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub flags: OpticalFlowExecuteFlagsNV,
    pub region_count: u32,
    pub regions: *const Rect2D,
}

impl Default for OpticalFlowExecuteInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::OPTICAL_FLOW_EXECUTE_INFO_NV,
            next: ptr::null_mut(),
            flags: OpticalFlowExecuteFlagsNV::default(),
            region_count: u32::default(),
            regions: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkOpticalFlowImageFormatInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct OpticalFlowImageFormatInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub usage: OpticalFlowUsageFlagsNV,
}

impl Default for OpticalFlowImageFormatInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV,
            next: ptr::null(),
            usage: OpticalFlowUsageFlagsNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkOpticalFlowImageFormatPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct OpticalFlowImageFormatPropertiesNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub format: Format,
}

impl Default for OpticalFlowImageFormatPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV,
            next: ptr::null(),
            format: Format::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkOpticalFlowSessionCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct OpticalFlowSessionCreateInfoNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub width: u32,
    pub height: u32,
    pub image_format: Format,
    pub flow_vector_format: Format,
    pub cost_format: Format,
    pub output_grid_size: OpticalFlowGridSizeFlagsNV,
    pub hint_grid_size: OpticalFlowGridSizeFlagsNV,
    pub performance_level: OpticalFlowPerformanceLevelNV,
    pub flags: OpticalFlowSessionCreateFlagsNV,
}

impl Default for OpticalFlowSessionCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::OPTICAL_FLOW_SESSION_CREATE_INFO_NV,
            next: ptr::null_mut(),
            width: u32::default(),
            height: u32::default(),
            image_format: Format::default(),
            flow_vector_format: Format::default(),
            cost_format: Format::default(),
            output_grid_size: OpticalFlowGridSizeFlagsNV::default(),
            hint_grid_size: OpticalFlowGridSizeFlagsNV::default(),
            performance_level: OpticalFlowPerformanceLevelNV::default(),
            flags: OpticalFlowSessionCreateFlagsNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkOpticalFlowSessionCreatePrivateDataInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct OpticalFlowSessionCreatePrivateDataInfoNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub id: u32,
    pub size: u32,
    pub private_data: *const c_void,
}

impl Default for OpticalFlowSessionCreatePrivateDataInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV,
            next: ptr::null_mut(),
            id: u32::default(),
            size: u32::default(),
            private_data: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkOutOfBandQueueTypeInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct OutOfBandQueueTypeInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub queue_type: OutOfBandQueueTypeNV,
}

impl Default for OutOfBandQueueTypeInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::OUT_OF_BAND_QUEUE_TYPE_INFO_NV,
            next: ptr::null(),
            queue_type: OutOfBandQueueTypeNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureFlagsNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PartitionedAccelerationStructureFlagsNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub enable_partition_translation: Bool32,
}

impl Default for PartitionedAccelerationStructureFlagsNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV,
            next: ptr::null_mut(),
            enable_partition_translation: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureInstancesInputNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PartitionedAccelerationStructureInstancesInputNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub flags: BuildAccelerationStructureFlagsKHR,
    pub instance_count: u32,
    pub max_instance_per_partition_count: u32,
    pub partition_count: u32,
    pub max_instance_in_global_partition_count: u32,
}

impl Default for PartitionedAccelerationStructureInstancesInputNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV,
            next: ptr::null_mut(),
            flags: BuildAccelerationStructureFlagsKHR::default(),
            instance_count: u32::default(),
            max_instance_per_partition_count: u32::default(),
            partition_count: u32::default(),
            max_instance_in_global_partition_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureUpdateInstanceDataNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct PartitionedAccelerationStructureUpdateInstanceDataNV {
    pub instance_index: u32,
    pub instance_contribution_to_hit_group_index: u32,
    pub acceleration_structure: DeviceAddress,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureWriteInstanceDataNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq)]
pub struct PartitionedAccelerationStructureWriteInstanceDataNV {
    pub transform: TransformMatrixKHR,
    pub explicit_aabb: [f32; 6],
    pub instance_id: u32,
    pub instance_mask: u32,
    pub instance_contribution_to_hit_group_index: u32,
    pub instance_flags: PartitionedAccelerationStructureInstanceFlagsNV,
    pub instance_index: u32,
    pub partition_index: u32,
    pub acceleration_structure: DeviceAddress,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureWritePartitionTranslationDataNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq)]
pub struct PartitionedAccelerationStructureWritePartitionTranslationDataNV {
    pub partition_index: u32,
    pub partition_translation: [f32; 3],
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPastPresentationTimingGOOGLE.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct PastPresentationTimingGOOGLE {
    pub present_id: u32,
    pub desired_present_time: u64,
    pub actual_present_time: u64,
    pub earliest_present_time: u64,
    pub present_margin: u64,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPerformanceConfigurationAcquireInfoINTEL.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PerformanceConfigurationAcquireInfoINTEL {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub type_: PerformanceConfigurationTypeINTEL,
}

impl Default for PerformanceConfigurationAcquireInfoINTEL {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL,
            next: ptr::null(),
            type_: PerformanceConfigurationTypeINTEL::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPerformanceCounterDescriptionKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PerformanceCounterDescriptionKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub flags: PerformanceCounterDescriptionFlagsKHR,
    pub name: StringArray<MAX_DESCRIPTION_SIZE>,
    pub category: StringArray<MAX_DESCRIPTION_SIZE>,
    pub description: StringArray<MAX_DESCRIPTION_SIZE>,
}

impl Default for PerformanceCounterDescriptionKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PERFORMANCE_COUNTER_DESCRIPTION_KHR,
            next: ptr::null_mut(),
            flags: PerformanceCounterDescriptionFlagsKHR::default(),
            name: StringArray::default(),
            category: StringArray::default(),
            description: StringArray::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPerformanceCounterKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PerformanceCounterKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub unit: PerformanceCounterUnitKHR,
    pub scope: PerformanceCounterScopeKHR,
    pub storage: PerformanceCounterStorageKHR,
    pub uuid: ByteArray<UUID_SIZE>,
}

impl Default for PerformanceCounterKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PERFORMANCE_COUNTER_KHR,
            next: ptr::null_mut(),
            unit: PerformanceCounterUnitKHR::default(),
            scope: PerformanceCounterScopeKHR::default(),
            storage: PerformanceCounterStorageKHR::default(),
            uuid: ByteArray::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPerformanceMarkerInfoINTEL.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PerformanceMarkerInfoINTEL {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub marker: u64,
}

impl Default for PerformanceMarkerInfoINTEL {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PERFORMANCE_MARKER_INFO_INTEL,
            next: ptr::null(),
            marker: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPerformanceOverrideInfoINTEL.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PerformanceOverrideInfoINTEL {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub type_: PerformanceOverrideTypeINTEL,
    pub enable: Bool32,
    pub parameter: u64,
}

impl Default for PerformanceOverrideInfoINTEL {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PERFORMANCE_OVERRIDE_INFO_INTEL,
            next: ptr::null(),
            type_: PerformanceOverrideTypeINTEL::default(),
            enable: Bool32::default(),
            parameter: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPerformanceQueryReservationInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PerformanceQueryReservationInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub max_performance_queries_per_pool: u32,
}

impl Default for PerformanceQueryReservationInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PERFORMANCE_QUERY_RESERVATION_INFO_KHR,
            next: ptr::null(),
            max_performance_queries_per_pool: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPerformanceQuerySubmitInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PerformanceQuerySubmitInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub counter_pass_index: u32,
}

impl Default for PerformanceQuerySubmitInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PERFORMANCE_QUERY_SUBMIT_INFO_KHR,
            next: ptr::null(),
            counter_pass_index: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPerformanceStreamMarkerInfoINTEL.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PerformanceStreamMarkerInfoINTEL {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub marker: u32,
}

impl Default for PerformanceStreamMarkerInfoINTEL {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PERFORMANCE_STREAM_MARKER_INFO_INTEL,
            next: ptr::null(),
            marker: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPerformanceValueINTEL.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
pub struct PerformanceValueINTEL {
    pub type_: PerformanceValueTypeINTEL,
    pub data: PerformanceValueDataINTEL,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevice16BitStorageFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevice16BitStorageFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub storage_buffer_16bit_access: Bool32,
    pub uniform_and_storage_buffer_16bit_access: Bool32,
    pub storage_push_constant16: Bool32,
    pub storage_input_output16: Bool32,
}

impl Default for PhysicalDevice16BitStorageFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
            next: ptr::null_mut(),
            storage_buffer_16bit_access: Bool32::default(),
            uniform_and_storage_buffer_16bit_access: Bool32::default(),
            storage_push_constant16: Bool32::default(),
            storage_input_output16: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevice4444FormatsFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevice4444FormatsFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub format_a4_r4_g4_b4: Bool32,
    pub format_a4_b4_g4_r4: Bool32,
}

impl Default for PhysicalDevice4444FormatsFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT,
            next: ptr::null_mut(),
            format_a4_r4_g4_b4: Bool32::default(),
            format_a4_b4_g4_r4: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevice8BitStorageFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevice8BitStorageFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub storage_buffer_8bit_access: Bool32,
    pub uniform_and_storage_buffer_8bit_access: Bool32,
    pub storage_push_constant8: Bool32,
}

impl Default for PhysicalDevice8BitStorageFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
            next: ptr::null_mut(),
            storage_buffer_8bit_access: Bool32::default(),
            uniform_and_storage_buffer_8bit_access: Bool32::default(),
            storage_push_constant8: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceASTCDecodeFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceASTCDecodeFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub decode_mode_shared_exponent: Bool32,
}

impl Default for PhysicalDeviceASTCDecodeFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT,
            next: ptr::null_mut(),
            decode_mode_shared_exponent: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceAccelerationStructureFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceAccelerationStructureFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub acceleration_structure: Bool32,
    pub acceleration_structure_capture_replay: Bool32,
    pub acceleration_structure_indirect_build: Bool32,
    pub acceleration_structure_host_commands: Bool32,
    pub descriptor_binding_acceleration_structure_update_after_bind: Bool32,
}

impl Default for PhysicalDeviceAccelerationStructureFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR,
            next: ptr::null_mut(),
            acceleration_structure: Bool32::default(),
            acceleration_structure_capture_replay: Bool32::default(),
            acceleration_structure_indirect_build: Bool32::default(),
            acceleration_structure_host_commands: Bool32::default(),
            descriptor_binding_acceleration_structure_update_after_bind: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceAccelerationStructurePropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_geometry_count: u64,
    pub max_instance_count: u64,
    pub max_primitive_count: u64,
    pub max_per_stage_descriptor_acceleration_structures: u32,
    pub max_per_stage_descriptor_update_after_bind_acceleration_structures: u32,
    pub max_descriptor_set_acceleration_structures: u32,
    pub max_descriptor_set_update_after_bind_acceleration_structures: u32,
    pub min_acceleration_structure_scratch_offset_alignment: u32,
}

impl Default for PhysicalDeviceAccelerationStructurePropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR,
            next: ptr::null_mut(),
            max_geometry_count: u64::default(),
            max_instance_count: u64::default(),
            max_primitive_count: u64::default(),
            max_per_stage_descriptor_acceleration_structures: u32::default(),
            max_per_stage_descriptor_update_after_bind_acceleration_structures: u32::default(),
            max_descriptor_set_acceleration_structures: u32::default(),
            max_descriptor_set_update_after_bind_acceleration_structures: u32::default(),
            min_acceleration_structure_scratch_offset_alignment: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceAddressBindingReportFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceAddressBindingReportFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub report_address_binding: Bool32,
}

impl Default for PhysicalDeviceAddressBindingReportFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT,
            next: ptr::null_mut(),
            report_address_binding: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceAmigoProfilingFeaturesSEC.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceAmigoProfilingFeaturesSEC {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub amigo_profiling: Bool32,
}

impl Default for PhysicalDeviceAmigoProfilingFeaturesSEC {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC,
            next: ptr::null_mut(),
            amigo_profiling: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceAntiLagFeaturesAMD.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceAntiLagFeaturesAMD {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub anti_lag: Bool32,
}

impl Default for PhysicalDeviceAntiLagFeaturesAMD {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD,
            next: ptr::null_mut(),
            anti_lag: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub attachment_feedback_loop_dynamic_state: Bool32,
}

impl Default for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type:
                StructureType::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT,
            next: ptr::null_mut(),
            attachment_feedback_loop_dynamic_state: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub attachment_feedback_loop_layout: Bool32,
}

impl Default for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT,
            next: ptr::null_mut(),
            attachment_feedback_loop_layout: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub advanced_blend_coherent_operations: Bool32,
}

impl Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT,
            next: ptr::null_mut(),
            advanced_blend_coherent_operations: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub advanced_blend_max_color_attachments: u32,
    pub advanced_blend_independent_blend: Bool32,
    pub advanced_blend_non_premultiplied_src_color: Bool32,
    pub advanced_blend_non_premultiplied_dst_color: Bool32,
    pub advanced_blend_correlated_overlap: Bool32,
    pub advanced_blend_all_operations: Bool32,
}

impl Default for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT,
            next: ptr::null_mut(),
            advanced_blend_max_color_attachments: u32::default(),
            advanced_blend_independent_blend: Bool32::default(),
            advanced_blend_non_premultiplied_src_color: Bool32::default(),
            advanced_blend_non_premultiplied_dst_color: Bool32::default(),
            advanced_blend_correlated_overlap: Bool32::default(),
            advanced_blend_all_operations: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub border_color_swizzle: Bool32,
    pub border_color_swizzle_from_image: Bool32,
}

impl Default for PhysicalDeviceBorderColorSwizzleFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT,
            next: ptr::null_mut(),
            border_color_swizzle: Bool32::default(),
            border_color_swizzle_from_image: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceBufferDeviceAddressFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceBufferDeviceAddressFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub buffer_device_address: Bool32,
    pub buffer_device_address_capture_replay: Bool32,
    pub buffer_device_address_multi_device: Bool32,
}

impl Default for PhysicalDeviceBufferDeviceAddressFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES,
            next: ptr::null_mut(),
            buffer_device_address: Bool32::default(),
            buffer_device_address_capture_replay: Bool32::default(),
            buffer_device_address_multi_device: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub buffer_device_address: Bool32,
    pub buffer_device_address_capture_replay: Bool32,
    pub buffer_device_address_multi_device: Bool32,
}

impl Default for PhysicalDeviceBufferDeviceAddressFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
            next: ptr::null_mut(),
            buffer_device_address: Bool32::default(),
            buffer_device_address_capture_replay: Bool32::default(),
            buffer_device_address_multi_device: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceClusterAccelerationStructureFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceClusterAccelerationStructureFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub cluster_acceleration_structure: Bool32,
}

impl Default for PhysicalDeviceClusterAccelerationStructureFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV,
            next: ptr::null_mut(),
            cluster_acceleration_structure: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceClusterAccelerationStructurePropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceClusterAccelerationStructurePropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_vertices_per_cluster: u32,
    pub max_triangles_per_cluster: u32,
    pub cluster_scratch_byte_alignment: u32,
    pub cluster_byte_alignment: u32,
    pub cluster_template_byte_alignment: u32,
    pub cluster_bottom_level_byte_alignment: u32,
    pub cluster_template_bounds_byte_alignment: u32,
    pub max_cluster_geometry_index: u32,
}

impl Default for PhysicalDeviceClusterAccelerationStructurePropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV,
            next: ptr::null_mut(),
            max_vertices_per_cluster: u32::default(),
            max_triangles_per_cluster: u32::default(),
            cluster_scratch_byte_alignment: u32::default(),
            cluster_byte_alignment: u32::default(),
            cluster_template_byte_alignment: u32::default(),
            cluster_bottom_level_byte_alignment: u32::default(),
            cluster_template_bounds_byte_alignment: u32::default(),
            max_cluster_geometry_index: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub clusterculling_shader: Bool32,
    pub multiview_cluster_culling_shader: Bool32,
}

impl Default for PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI,
            next: ptr::null_mut(),
            clusterculling_shader: Bool32::default(),
            multiview_cluster_culling_shader: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_work_group_count: [u32; 3],
    pub max_work_group_size: [u32; 3],
    pub max_output_cluster_count: u32,
    pub indirect_buffer_offset_alignment: DeviceSize,
}

impl Default for PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI,
            next: ptr::null_mut(),
            max_work_group_count: [u32::default(); 3],
            max_work_group_size: [u32::default(); 3],
            max_output_cluster_count: u32::default(),
            indirect_buffer_offset_alignment: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub cluster_shading_rate: Bool32,
}

impl Default for PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI,
            next: ptr::null_mut(),
            cluster_shading_rate: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCoherentMemoryFeaturesAMD.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCoherentMemoryFeaturesAMD {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub device_coherent_memory: Bool32,
}

impl Default for PhysicalDeviceCoherentMemoryFeaturesAMD {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD,
            next: ptr::null_mut(),
            device_coherent_memory: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceColorWriteEnableFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceColorWriteEnableFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub color_write_enable: Bool32,
}

impl Default for PhysicalDeviceColorWriteEnableFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT,
            next: ptr::null_mut(),
            color_write_enable: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCommandBufferInheritanceFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCommandBufferInheritanceFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub command_buffer_inheritance: Bool32,
}

impl Default for PhysicalDeviceCommandBufferInheritanceFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV,
            next: ptr::null_mut(),
            command_buffer_inheritance: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceComputeShaderDerivativesFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub compute_derivative_group_quads: Bool32,
    pub compute_derivative_group_linear: Bool32,
}

impl Default for PhysicalDeviceComputeShaderDerivativesFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR,
            next: ptr::null_mut(),
            compute_derivative_group_quads: Bool32::default(),
            compute_derivative_group_linear: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceComputeShaderDerivativesPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub mesh_and_task_shader_derivatives: Bool32,
}

impl Default for PhysicalDeviceComputeShaderDerivativesPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR,
            next: ptr::null_mut(),
            mesh_and_task_shader_derivatives: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceConditionalRenderingFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceConditionalRenderingFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub conditional_rendering: Bool32,
    pub inherited_conditional_rendering: Bool32,
}

impl Default for PhysicalDeviceConditionalRenderingFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT,
            next: ptr::null_mut(),
            conditional_rendering: Bool32::default(),
            inherited_conditional_rendering: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub primitive_overestimation_size: f32,
    pub max_extra_primitive_overestimation_size: f32,
    pub extra_primitive_overestimation_size_granularity: f32,
    pub primitive_underestimation: Bool32,
    pub conservative_point_and_line_rasterization: Bool32,
    pub degenerate_triangles_rasterized: Bool32,
    pub degenerate_lines_rasterized: Bool32,
    pub fully_covered_fragment_shader_input_variable: Bool32,
    pub conservative_rasterization_post_depth_coverage: Bool32,
}

impl Default for PhysicalDeviceConservativeRasterizationPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT,
            next: ptr::null_mut(),
            primitive_overestimation_size: f32::default(),
            max_extra_primitive_overestimation_size: f32::default(),
            extra_primitive_overestimation_size_granularity: f32::default(),
            primitive_underestimation: Bool32::default(),
            conservative_point_and_line_rasterization: Bool32::default(),
            degenerate_triangles_rasterized: Bool32::default(),
            degenerate_lines_rasterized: Bool32::default(),
            fully_covered_fragment_shader_input_variable: Bool32::default(),
            conservative_rasterization_post_depth_coverage: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrix2FeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCooperativeMatrix2FeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub cooperative_matrix_workgroup_scope: Bool32,
    pub cooperative_matrix_flexible_dimensions: Bool32,
    pub cooperative_matrix_reductions: Bool32,
    pub cooperative_matrix_conversions: Bool32,
    pub cooperative_matrix_per_element_operations: Bool32,
    pub cooperative_matrix_tensor_addressing: Bool32,
    pub cooperative_matrix_block_loads: Bool32,
}

impl Default for PhysicalDeviceCooperativeMatrix2FeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV,
            next: ptr::null_mut(),
            cooperative_matrix_workgroup_scope: Bool32::default(),
            cooperative_matrix_flexible_dimensions: Bool32::default(),
            cooperative_matrix_reductions: Bool32::default(),
            cooperative_matrix_conversions: Bool32::default(),
            cooperative_matrix_per_element_operations: Bool32::default(),
            cooperative_matrix_tensor_addressing: Bool32::default(),
            cooperative_matrix_block_loads: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrix2PropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCooperativeMatrix2PropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub cooperative_matrix_workgroup_scope_max_workgroup_size: u32,
    pub cooperative_matrix_flexible_dimensions_max_dimension: u32,
    pub cooperative_matrix_workgroup_scope_reserved_shared_memory: u32,
}

impl Default for PhysicalDeviceCooperativeMatrix2PropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV,
            next: ptr::null_mut(),
            cooperative_matrix_workgroup_scope_max_workgroup_size: u32::default(),
            cooperative_matrix_flexible_dimensions_max_dimension: u32::default(),
            cooperative_matrix_workgroup_scope_reserved_shared_memory: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCooperativeMatrixFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub cooperative_matrix: Bool32,
    pub cooperative_matrix_robust_buffer_access: Bool32,
}

impl Default for PhysicalDeviceCooperativeMatrixFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR,
            next: ptr::null_mut(),
            cooperative_matrix: Bool32::default(),
            cooperative_matrix_robust_buffer_access: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCooperativeMatrixFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub cooperative_matrix: Bool32,
    pub cooperative_matrix_robust_buffer_access: Bool32,
}

impl Default for PhysicalDeviceCooperativeMatrixFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV,
            next: ptr::null_mut(),
            cooperative_matrix: Bool32::default(),
            cooperative_matrix_robust_buffer_access: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCooperativeMatrixPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub cooperative_matrix_supported_stages: ShaderStageFlags,
}

impl Default for PhysicalDeviceCooperativeMatrixPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR,
            next: ptr::null_mut(),
            cooperative_matrix_supported_stages: ShaderStageFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCooperativeMatrixPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub cooperative_matrix_supported_stages: ShaderStageFlags,
}

impl Default for PhysicalDeviceCooperativeMatrixPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV,
            next: ptr::null_mut(),
            cooperative_matrix_supported_stages: ShaderStageFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeVectorFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCooperativeVectorFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub cooperative_vector: Bool32,
    pub cooperative_vector_training: Bool32,
}

impl Default for PhysicalDeviceCooperativeVectorFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV,
            next: ptr::null_mut(),
            cooperative_vector: Bool32::default(),
            cooperative_vector_training: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeVectorPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCooperativeVectorPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub cooperative_vector_supported_stages: ShaderStageFlags,
    pub cooperative_vector_training_float16_accumulation: Bool32,
    pub cooperative_vector_training_float32_accumulation: Bool32,
    pub max_cooperative_vector_components: u32,
}

impl Default for PhysicalDeviceCooperativeVectorPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV,
            next: ptr::null_mut(),
            cooperative_vector_supported_stages: ShaderStageFlags::default(),
            cooperative_vector_training_float16_accumulation: Bool32::default(),
            cooperative_vector_training_float32_accumulation: Bool32::default(),
            max_cooperative_vector_components: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCopyMemoryIndirectFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub indirect_copy: Bool32,
}

impl Default for PhysicalDeviceCopyMemoryIndirectFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV,
            next: ptr::null_mut(),
            indirect_copy: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCopyMemoryIndirectPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCopyMemoryIndirectPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub supported_queues: QueueFlags,
}

impl Default for PhysicalDeviceCopyMemoryIndirectPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV,
            next: ptr::null_mut(),
            supported_queues: QueueFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCornerSampledImageFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCornerSampledImageFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub corner_sampled_image: Bool32,
}

impl Default for PhysicalDeviceCornerSampledImageFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV,
            next: ptr::null_mut(),
            corner_sampled_image: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCoverageReductionModeFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCoverageReductionModeFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub coverage_reduction_mode: Bool32,
}

impl Default for PhysicalDeviceCoverageReductionModeFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV,
            next: ptr::null_mut(),
            coverage_reduction_mode: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCubicClampFeaturesQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCubicClampFeaturesQCOM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub cubic_range_clamp: Bool32,
}

impl Default for PhysicalDeviceCubicClampFeaturesQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM,
            next: ptr::null_mut(),
            cubic_range_clamp: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCubicWeightsFeaturesQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCubicWeightsFeaturesQCOM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub selectable_cubic_weights: Bool32,
}

impl Default for PhysicalDeviceCubicWeightsFeaturesQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM,
            next: ptr::null_mut(),
            selectable_cubic_weights: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCudaKernelLaunchFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCudaKernelLaunchFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub cuda_kernel_launch_features: Bool32,
}

impl Default for PhysicalDeviceCudaKernelLaunchFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV,
            next: ptr::null_mut(),
            cuda_kernel_launch_features: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCudaKernelLaunchPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCudaKernelLaunchPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub compute_capability_minor: u32,
    pub compute_capability_major: u32,
}

impl Default for PhysicalDeviceCudaKernelLaunchPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV,
            next: ptr::null_mut(),
            compute_capability_minor: u32::default(),
            compute_capability_major: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCustomBorderColorFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCustomBorderColorFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub custom_border_colors: Bool32,
    pub custom_border_color_without_format: Bool32,
}

impl Default for PhysicalDeviceCustomBorderColorFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT,
            next: ptr::null_mut(),
            custom_border_colors: Bool32::default(),
            custom_border_color_without_format: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceCustomBorderColorPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceCustomBorderColorPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_custom_border_color_samplers: u32,
}

impl Default for PhysicalDeviceCustomBorderColorPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT,
            next: ptr::null_mut(),
            max_custom_border_color_samplers: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub dedicated_allocation_image_aliasing: Bool32,
}

impl Default for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV,
            next: ptr::null_mut(),
            dedicated_allocation_image_aliasing: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthBiasControlFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDepthBiasControlFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub depth_bias_control: Bool32,
    pub least_representable_value_force_unorm_representation: Bool32,
    pub float_representation: Bool32,
    pub depth_bias_exact: Bool32,
}

impl Default for PhysicalDeviceDepthBiasControlFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT,
            next: ptr::null_mut(),
            depth_bias_control: Bool32::default(),
            least_representable_value_force_unorm_representation: Bool32::default(),
            float_representation: Bool32::default(),
            depth_bias_exact: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthClampControlFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDepthClampControlFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub depth_clamp_control: Bool32,
}

impl Default for PhysicalDeviceDepthClampControlFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT,
            next: ptr::null_mut(),
            depth_clamp_control: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthClampZeroOneFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDepthClampZeroOneFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub depth_clamp_zero_one: Bool32,
}

impl Default for PhysicalDeviceDepthClampZeroOneFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR,
            next: ptr::null_mut(),
            depth_clamp_zero_one: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthClipControlFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDepthClipControlFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub depth_clip_control: Bool32,
}

impl Default for PhysicalDeviceDepthClipControlFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT,
            next: ptr::null_mut(),
            depth_clip_control: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthClipEnableFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDepthClipEnableFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub depth_clip_enable: Bool32,
}

impl Default for PhysicalDeviceDepthClipEnableFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT,
            next: ptr::null_mut(),
            depth_clip_enable: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthStencilResolveProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDepthStencilResolveProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub supported_depth_resolve_modes: ResolveModeFlags,
    pub supported_stencil_resolve_modes: ResolveModeFlags,
    pub independent_resolve_none: Bool32,
    pub independent_resolve: Bool32,
}

impl Default for PhysicalDeviceDepthStencilResolveProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES,
            next: ptr::null_mut(),
            supported_depth_resolve_modes: ResolveModeFlags::default(),
            supported_stencil_resolve_modes: ResolveModeFlags::default(),
            independent_resolve_none: Bool32::default(),
            independent_resolve: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub combined_image_sampler_density_map_descriptor_size: usize,
}

impl Default for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT,
            next: ptr::null_mut(),
            combined_image_sampler_density_map_descriptor_size: usize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorBufferFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDescriptorBufferFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub descriptor_buffer: Bool32,
    pub descriptor_buffer_capture_replay: Bool32,
    pub descriptor_buffer_image_layout_ignored: Bool32,
    pub descriptor_buffer_push_descriptors: Bool32,
}

impl Default for PhysicalDeviceDescriptorBufferFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT,
            next: ptr::null_mut(),
            descriptor_buffer: Bool32::default(),
            descriptor_buffer_capture_replay: Bool32::default(),
            descriptor_buffer_image_layout_ignored: Bool32::default(),
            descriptor_buffer_push_descriptors: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorBufferPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDescriptorBufferPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub combined_image_sampler_descriptor_single_array: Bool32,
    pub bufferless_push_descriptors: Bool32,
    pub allow_sampler_image_view_post_submit_creation: Bool32,
    pub descriptor_buffer_offset_alignment: DeviceSize,
    pub max_descriptor_buffer_bindings: u32,
    pub max_resource_descriptor_buffer_bindings: u32,
    pub max_sampler_descriptor_buffer_bindings: u32,
    pub max_embedded_immutable_sampler_bindings: u32,
    pub max_embedded_immutable_samplers: u32,
    pub buffer_capture_replay_descriptor_data_size: usize,
    pub image_capture_replay_descriptor_data_size: usize,
    pub image_view_capture_replay_descriptor_data_size: usize,
    pub sampler_capture_replay_descriptor_data_size: usize,
    pub acceleration_structure_capture_replay_descriptor_data_size: usize,
    pub sampler_descriptor_size: usize,
    pub combined_image_sampler_descriptor_size: usize,
    pub sampled_image_descriptor_size: usize,
    pub storage_image_descriptor_size: usize,
    pub uniform_texel_buffer_descriptor_size: usize,
    pub robust_uniform_texel_buffer_descriptor_size: usize,
    pub storage_texel_buffer_descriptor_size: usize,
    pub robust_storage_texel_buffer_descriptor_size: usize,
    pub uniform_buffer_descriptor_size: usize,
    pub robust_uniform_buffer_descriptor_size: usize,
    pub storage_buffer_descriptor_size: usize,
    pub robust_storage_buffer_descriptor_size: usize,
    pub input_attachment_descriptor_size: usize,
    pub acceleration_structure_descriptor_size: usize,
    pub max_sampler_descriptor_buffer_range: DeviceSize,
    pub max_resource_descriptor_buffer_range: DeviceSize,
    pub sampler_descriptor_buffer_address_space_size: DeviceSize,
    pub resource_descriptor_buffer_address_space_size: DeviceSize,
    pub descriptor_buffer_address_space_size: DeviceSize,
}

impl Default for PhysicalDeviceDescriptorBufferPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT,
            next: ptr::null_mut(),
            combined_image_sampler_descriptor_single_array: Bool32::default(),
            bufferless_push_descriptors: Bool32::default(),
            allow_sampler_image_view_post_submit_creation: Bool32::default(),
            descriptor_buffer_offset_alignment: DeviceSize::default(),
            max_descriptor_buffer_bindings: u32::default(),
            max_resource_descriptor_buffer_bindings: u32::default(),
            max_sampler_descriptor_buffer_bindings: u32::default(),
            max_embedded_immutable_sampler_bindings: u32::default(),
            max_embedded_immutable_samplers: u32::default(),
            buffer_capture_replay_descriptor_data_size: usize::default(),
            image_capture_replay_descriptor_data_size: usize::default(),
            image_view_capture_replay_descriptor_data_size: usize::default(),
            sampler_capture_replay_descriptor_data_size: usize::default(),
            acceleration_structure_capture_replay_descriptor_data_size: usize::default(),
            sampler_descriptor_size: usize::default(),
            combined_image_sampler_descriptor_size: usize::default(),
            sampled_image_descriptor_size: usize::default(),
            storage_image_descriptor_size: usize::default(),
            uniform_texel_buffer_descriptor_size: usize::default(),
            robust_uniform_texel_buffer_descriptor_size: usize::default(),
            storage_texel_buffer_descriptor_size: usize::default(),
            robust_storage_texel_buffer_descriptor_size: usize::default(),
            uniform_buffer_descriptor_size: usize::default(),
            robust_uniform_buffer_descriptor_size: usize::default(),
            storage_buffer_descriptor_size: usize::default(),
            robust_storage_buffer_descriptor_size: usize::default(),
            input_attachment_descriptor_size: usize::default(),
            acceleration_structure_descriptor_size: usize::default(),
            max_sampler_descriptor_buffer_range: DeviceSize::default(),
            max_resource_descriptor_buffer_range: DeviceSize::default(),
            sampler_descriptor_buffer_address_space_size: DeviceSize::default(),
            resource_descriptor_buffer_address_space_size: DeviceSize::default(),
            descriptor_buffer_address_space_size: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorIndexingFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDescriptorIndexingFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_input_attachment_array_dynamic_indexing: Bool32,
    pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32,
    pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32,
    pub shader_uniform_buffer_array_non_uniform_indexing: Bool32,
    pub shader_sampled_image_array_non_uniform_indexing: Bool32,
    pub shader_storage_buffer_array_non_uniform_indexing: Bool32,
    pub shader_storage_image_array_non_uniform_indexing: Bool32,
    pub shader_input_attachment_array_non_uniform_indexing: Bool32,
    pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32,
    pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32,
    pub descriptor_binding_uniform_buffer_update_after_bind: Bool32,
    pub descriptor_binding_sampled_image_update_after_bind: Bool32,
    pub descriptor_binding_storage_image_update_after_bind: Bool32,
    pub descriptor_binding_storage_buffer_update_after_bind: Bool32,
    pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32,
    pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32,
    pub descriptor_binding_update_unused_while_pending: Bool32,
    pub descriptor_binding_partially_bound: Bool32,
    pub descriptor_binding_variable_descriptor_count: Bool32,
    pub runtime_descriptor_array: Bool32,
}

impl Default for PhysicalDeviceDescriptorIndexingFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES,
            next: ptr::null_mut(),
            shader_input_attachment_array_dynamic_indexing: Bool32::default(),
            shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(),
            shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(),
            shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(),
            shader_sampled_image_array_non_uniform_indexing: Bool32::default(),
            shader_storage_buffer_array_non_uniform_indexing: Bool32::default(),
            shader_storage_image_array_non_uniform_indexing: Bool32::default(),
            shader_input_attachment_array_non_uniform_indexing: Bool32::default(),
            shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(),
            shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(),
            descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(),
            descriptor_binding_sampled_image_update_after_bind: Bool32::default(),
            descriptor_binding_storage_image_update_after_bind: Bool32::default(),
            descriptor_binding_storage_buffer_update_after_bind: Bool32::default(),
            descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(),
            descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(),
            descriptor_binding_update_unused_while_pending: Bool32::default(),
            descriptor_binding_partially_bound: Bool32::default(),
            descriptor_binding_variable_descriptor_count: Bool32::default(),
            runtime_descriptor_array: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorIndexingProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDescriptorIndexingProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_update_after_bind_descriptors_in_all_pools: u32,
    pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32,
    pub shader_sampled_image_array_non_uniform_indexing_native: Bool32,
    pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32,
    pub shader_storage_image_array_non_uniform_indexing_native: Bool32,
    pub shader_input_attachment_array_non_uniform_indexing_native: Bool32,
    pub robust_buffer_access_update_after_bind: Bool32,
    pub quad_divergent_implicit_lod: Bool32,
    pub max_per_stage_descriptor_update_after_bind_samplers: u32,
    pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
    pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
    pub max_per_stage_descriptor_update_after_bind_sampled_images: u32,
    pub max_per_stage_descriptor_update_after_bind_storage_images: u32,
    pub max_per_stage_descriptor_update_after_bind_input_attachments: u32,
    pub max_per_stage_update_after_bind_resources: u32,
    pub max_descriptor_set_update_after_bind_samplers: u32,
    pub max_descriptor_set_update_after_bind_uniform_buffers: u32,
    pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_storage_buffers: u32,
    pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_sampled_images: u32,
    pub max_descriptor_set_update_after_bind_storage_images: u32,
    pub max_descriptor_set_update_after_bind_input_attachments: u32,
}

impl Default for PhysicalDeviceDescriptorIndexingProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES,
            next: ptr::null_mut(),
            max_update_after_bind_descriptors_in_all_pools: u32::default(),
            shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(),
            shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(),
            shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(),
            shader_storage_image_array_non_uniform_indexing_native: Bool32::default(),
            shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(),
            robust_buffer_access_update_after_bind: Bool32::default(),
            quad_divergent_implicit_lod: Bool32::default(),
            max_per_stage_descriptor_update_after_bind_samplers: u32::default(),
            max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(),
            max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(),
            max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(),
            max_per_stage_descriptor_update_after_bind_storage_images: u32::default(),
            max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(),
            max_per_stage_update_after_bind_resources: u32::default(),
            max_descriptor_set_update_after_bind_samplers: u32::default(),
            max_descriptor_set_update_after_bind_uniform_buffers: u32::default(),
            max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(),
            max_descriptor_set_update_after_bind_storage_buffers: u32::default(),
            max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(),
            max_descriptor_set_update_after_bind_sampled_images: u32::default(),
            max_descriptor_set_update_after_bind_storage_images: u32::default(),
            max_descriptor_set_update_after_bind_input_attachments: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub descriptor_pool_overallocation: Bool32,
}

impl Default for PhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV,
            next: ptr::null_mut(),
            descriptor_pool_overallocation: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub descriptor_set_host_mapping: Bool32,
}

impl Default for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE,
            next: ptr::null_mut(),
            descriptor_set_host_mapping: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub device_generated_compute: Bool32,
    pub device_generated_compute_pipelines: Bool32,
    pub device_generated_compute_capture_replay: Bool32,
}

impl Default for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV,
            next: ptr::null_mut(),
            device_generated_compute: Bool32::default(),
            device_generated_compute_pipelines: Bool32::default(),
            device_generated_compute_capture_replay: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub device_generated_commands: Bool32,
    pub dynamic_generated_pipeline_layout: Bool32,
}

impl Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT,
            next: ptr::null_mut(),
            device_generated_commands: Bool32::default(),
            dynamic_generated_pipeline_layout: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub device_generated_commands: Bool32,
}

impl Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV,
            next: ptr::null_mut(),
            device_generated_commands: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_indirect_pipeline_count: u32,
    pub max_indirect_shader_object_count: u32,
    pub max_indirect_sequence_count: u32,
    pub max_indirect_commands_token_count: u32,
    pub max_indirect_commands_token_offset: u32,
    pub max_indirect_commands_indirect_stride: u32,
    pub supported_indirect_commands_input_modes: IndirectCommandsInputModeFlagsEXT,
    pub supported_indirect_commands_shader_stages: ShaderStageFlags,
    pub supported_indirect_commands_shader_stages_pipeline_binding: ShaderStageFlags,
    pub supported_indirect_commands_shader_stages_shader_binding: ShaderStageFlags,
    pub device_generated_commands_transform_feedback: Bool32,
    pub device_generated_commands_multi_draw_indirect_count: Bool32,
}

impl Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT,
            next: ptr::null_mut(),
            max_indirect_pipeline_count: u32::default(),
            max_indirect_shader_object_count: u32::default(),
            max_indirect_sequence_count: u32::default(),
            max_indirect_commands_token_count: u32::default(),
            max_indirect_commands_token_offset: u32::default(),
            max_indirect_commands_indirect_stride: u32::default(),
            supported_indirect_commands_input_modes: IndirectCommandsInputModeFlagsEXT::default(),
            supported_indirect_commands_shader_stages: ShaderStageFlags::default(),
            supported_indirect_commands_shader_stages_pipeline_binding: ShaderStageFlags::default(),
            supported_indirect_commands_shader_stages_shader_binding: ShaderStageFlags::default(),
            device_generated_commands_transform_feedback: Bool32::default(),
            device_generated_commands_multi_draw_indirect_count: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_graphics_shader_group_count: u32,
    pub max_indirect_sequence_count: u32,
    pub max_indirect_commands_token_count: u32,
    pub max_indirect_commands_stream_count: u32,
    pub max_indirect_commands_token_offset: u32,
    pub max_indirect_commands_stream_stride: u32,
    pub min_sequences_count_buffer_offset_alignment: u32,
    pub min_sequences_index_buffer_offset_alignment: u32,
    pub min_indirect_commands_buffer_offset_alignment: u32,
}

impl Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV,
            next: ptr::null_mut(),
            max_graphics_shader_group_count: u32::default(),
            max_indirect_sequence_count: u32::default(),
            max_indirect_commands_token_count: u32::default(),
            max_indirect_commands_stream_count: u32::default(),
            max_indirect_commands_token_offset: u32::default(),
            max_indirect_commands_stream_stride: u32::default(),
            min_sequences_count_buffer_offset_alignment: u32::default(),
            min_sequences_index_buffer_offset_alignment: u32::default(),
            min_indirect_commands_buffer_offset_alignment: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub device_memory_report: Bool32,
}

impl Default for PhysicalDeviceDeviceMemoryReportFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT,
            next: ptr::null_mut(),
            device_memory_report: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDiagnosticsConfigFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDiagnosticsConfigFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub diagnostics_config: Bool32,
}

impl Default for PhysicalDeviceDiagnosticsConfigFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV,
            next: ptr::null_mut(),
            diagnostics_config: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDiscardRectanglePropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDiscardRectanglePropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_discard_rectangles: u32,
}

impl Default for PhysicalDeviceDiscardRectanglePropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT,
            next: ptr::null_mut(),
            max_discard_rectangles: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDisplacementMicromapFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDisplacementMicromapFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub displacement_micromap: Bool32,
}

impl Default for PhysicalDeviceDisplacementMicromapFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV,
            next: ptr::null_mut(),
            displacement_micromap: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDisplacementMicromapPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDisplacementMicromapPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_displacement_micromap_subdivision_level: u32,
}

impl Default for PhysicalDeviceDisplacementMicromapPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV,
            next: ptr::null_mut(),
            max_displacement_micromap_subdivision_level: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDriverProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDriverProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub driver_id: DriverId,
    pub driver_name: StringArray<MAX_DRIVER_NAME_SIZE>,
    pub driver_info: StringArray<MAX_DRIVER_INFO_SIZE>,
    pub conformance_version: ConformanceVersion,
}

impl Default for PhysicalDeviceDriverProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DRIVER_PROPERTIES,
            next: ptr::null_mut(),
            driver_id: DriverId::default(),
            driver_name: StringArray::default(),
            driver_info: StringArray::default(),
            conformance_version: ConformanceVersion::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDrmPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDrmPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub has_primary: Bool32,
    pub has_render: Bool32,
    pub primary_major: i64,
    pub primary_minor: i64,
    pub render_major: i64,
    pub render_minor: i64,
}

impl Default for PhysicalDeviceDrmPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT,
            next: ptr::null_mut(),
            has_primary: Bool32::default(),
            has_render: Bool32::default(),
            primary_major: i64::default(),
            primary_minor: i64::default(),
            render_major: i64::default(),
            render_minor: i64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDynamicRenderingFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDynamicRenderingFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub dynamic_rendering: Bool32,
}

impl Default for PhysicalDeviceDynamicRenderingFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES,
            next: ptr::null_mut(),
            dynamic_rendering: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDynamicRenderingLocalReadFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDynamicRenderingLocalReadFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub dynamic_rendering_local_read: Bool32,
}

impl Default for PhysicalDeviceDynamicRenderingLocalReadFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES,
            next: ptr::null_mut(),
            dynamic_rendering_local_read: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub dynamic_rendering_unused_attachments: Bool32,
}

impl Default for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type:
                StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT,
            next: ptr::null_mut(),
            dynamic_rendering_unused_attachments: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExclusiveScissorFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExclusiveScissorFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub exclusive_scissor: Bool32,
}

impl Default for PhysicalDeviceExclusiveScissorFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV,
            next: ptr::null_mut(),
            exclusive_scissor: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub extended_dynamic_state2: Bool32,
    pub extended_dynamic_state2_logic_op: Bool32,
    pub extended_dynamic_state2_patch_control_points: Bool32,
}

impl Default for PhysicalDeviceExtendedDynamicState2FeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT,
            next: ptr::null_mut(),
            extended_dynamic_state2: Bool32::default(),
            extended_dynamic_state2_logic_op: Bool32::default(),
            extended_dynamic_state2_patch_control_points: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExtendedDynamicState3FeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub extended_dynamic_state3_tessellation_domain_origin: Bool32,
    pub extended_dynamic_state_3depth_clamp_enable: Bool32,
    pub extended_dynamic_state3_polygon_mode: Bool32,
    pub extended_dynamic_state3_rasterization_samples: Bool32,
    pub extended_dynamic_state3_sample_mask: Bool32,
    pub extended_dynamic_state3_alpha_to_coverage_enable: Bool32,
    pub extended_dynamic_state3_alpha_to_one_enable: Bool32,
    pub extended_dynamic_state3_logic_op_enable: Bool32,
    pub extended_dynamic_state3_color_blend_enable: Bool32,
    pub extended_dynamic_state3_color_blend_equation: Bool32,
    pub extended_dynamic_state3_color_write_mask: Bool32,
    pub extended_dynamic_state3_rasterization_stream: Bool32,
    pub extended_dynamic_state3_conservative_rasterization_mode: Bool32,
    pub extended_dynamic_state3_extra_primitive_overestimation_size: Bool32,
    pub extended_dynamic_state_3depth_clip_enable: Bool32,
    pub extended_dynamic_state3_sample_locations_enable: Bool32,
    pub extended_dynamic_state3_color_blend_advanced: Bool32,
    pub extended_dynamic_state3_provoking_vertex_mode: Bool32,
    pub extended_dynamic_state3_line_rasterization_mode: Bool32,
    pub extended_dynamic_state3_line_stipple_enable: Bool32,
    pub extended_dynamic_state_3depth_clip_negative_one_to_one: Bool32,
    pub extended_dynamic_state3_viewport_w_scaling_enable: Bool32,
    pub extended_dynamic_state3_viewport_swizzle: Bool32,
    pub extended_dynamic_state3_coverage_to_color_enable: Bool32,
    pub extended_dynamic_state3_coverage_to_color_location: Bool32,
    pub extended_dynamic_state3_coverage_modulation_mode: Bool32,
    pub extended_dynamic_state3_coverage_modulation_table_enable: Bool32,
    pub extended_dynamic_state3_coverage_modulation_table: Bool32,
    pub extended_dynamic_state3_coverage_reduction_mode: Bool32,
    pub extended_dynamic_state3_representative_fragment_test_enable: Bool32,
    pub extended_dynamic_state3_shading_rate_image_enable: Bool32,
}

impl Default for PhysicalDeviceExtendedDynamicState3FeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT,
            next: ptr::null_mut(),
            extended_dynamic_state3_tessellation_domain_origin: Bool32::default(),
            extended_dynamic_state_3depth_clamp_enable: Bool32::default(),
            extended_dynamic_state3_polygon_mode: Bool32::default(),
            extended_dynamic_state3_rasterization_samples: Bool32::default(),
            extended_dynamic_state3_sample_mask: Bool32::default(),
            extended_dynamic_state3_alpha_to_coverage_enable: Bool32::default(),
            extended_dynamic_state3_alpha_to_one_enable: Bool32::default(),
            extended_dynamic_state3_logic_op_enable: Bool32::default(),
            extended_dynamic_state3_color_blend_enable: Bool32::default(),
            extended_dynamic_state3_color_blend_equation: Bool32::default(),
            extended_dynamic_state3_color_write_mask: Bool32::default(),
            extended_dynamic_state3_rasterization_stream: Bool32::default(),
            extended_dynamic_state3_conservative_rasterization_mode: Bool32::default(),
            extended_dynamic_state3_extra_primitive_overestimation_size: Bool32::default(),
            extended_dynamic_state_3depth_clip_enable: Bool32::default(),
            extended_dynamic_state3_sample_locations_enable: Bool32::default(),
            extended_dynamic_state3_color_blend_advanced: Bool32::default(),
            extended_dynamic_state3_provoking_vertex_mode: Bool32::default(),
            extended_dynamic_state3_line_rasterization_mode: Bool32::default(),
            extended_dynamic_state3_line_stipple_enable: Bool32::default(),
            extended_dynamic_state_3depth_clip_negative_one_to_one: Bool32::default(),
            extended_dynamic_state3_viewport_w_scaling_enable: Bool32::default(),
            extended_dynamic_state3_viewport_swizzle: Bool32::default(),
            extended_dynamic_state3_coverage_to_color_enable: Bool32::default(),
            extended_dynamic_state3_coverage_to_color_location: Bool32::default(),
            extended_dynamic_state3_coverage_modulation_mode: Bool32::default(),
            extended_dynamic_state3_coverage_modulation_table_enable: Bool32::default(),
            extended_dynamic_state3_coverage_modulation_table: Bool32::default(),
            extended_dynamic_state3_coverage_reduction_mode: Bool32::default(),
            extended_dynamic_state3_representative_fragment_test_enable: Bool32::default(),
            extended_dynamic_state3_shading_rate_image_enable: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedDynamicState3PropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExtendedDynamicState3PropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub dynamic_primitive_topology_unrestricted: Bool32,
}

impl Default for PhysicalDeviceExtendedDynamicState3PropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT,
            next: ptr::null_mut(),
            dynamic_primitive_topology_unrestricted: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub extended_dynamic_state: Bool32,
}

impl Default for PhysicalDeviceExtendedDynamicStateFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT,
            next: ptr::null_mut(),
            extended_dynamic_state: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub extended_sparse_address_space: Bool32,
}

impl Default for PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV,
            next: ptr::null_mut(),
            extended_sparse_address_space: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub extended_sparse_address_space_size: DeviceSize,
    pub extended_sparse_image_usage_flags: ImageUsageFlags,
    pub extended_sparse_buffer_usage_flags: BufferUsageFlags,
}

impl Default for PhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV,
            next: ptr::null_mut(),
            extended_sparse_address_space_size: DeviceSize::default(),
            extended_sparse_image_usage_flags: ImageUsageFlags::default(),
            extended_sparse_buffer_usage_flags: BufferUsageFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalBufferInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExternalBufferInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: BufferCreateFlags,
    pub usage: BufferUsageFlags,
    pub handle_type: ExternalMemoryHandleTypeFlags,
}

impl Default for PhysicalDeviceExternalBufferInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
            next: ptr::null(),
            flags: BufferCreateFlags::default(),
            usage: BufferUsageFlags::default(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalFenceInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExternalFenceInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_type: ExternalFenceHandleTypeFlags,
}

impl Default for PhysicalDeviceExternalFenceInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
            next: ptr::null(),
            handle_type: ExternalFenceHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalFormatResolveFeaturesANDROID.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExternalFormatResolveFeaturesANDROID {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub external_format_resolve: Bool32,
}

impl Default for PhysicalDeviceExternalFormatResolveFeaturesANDROID {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID,
            next: ptr::null_mut(),
            external_format_resolve: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalFormatResolvePropertiesANDROID.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExternalFormatResolvePropertiesANDROID {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub null_color_attachment_with_external_format_resolve: Bool32,
    pub external_format_resolve_chroma_offset_x: ChromaLocation,
    pub external_format_resolve_chroma_offset_y: ChromaLocation,
}

impl Default for PhysicalDeviceExternalFormatResolvePropertiesANDROID {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID,
            next: ptr::null_mut(),
            null_color_attachment_with_external_format_resolve: Bool32::default(),
            external_format_resolve_chroma_offset_x: ChromaLocation::default(),
            external_format_resolve_chroma_offset_y: ChromaLocation::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalImageFormatInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExternalImageFormatInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
}

impl Default for PhysicalDeviceExternalImageFormatInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
            next: ptr::null(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalMemoryHostPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub min_imported_host_pointer_alignment: DeviceSize,
}

impl Default for PhysicalDeviceExternalMemoryHostPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
            next: ptr::null_mut(),
            min_imported_host_pointer_alignment: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub external_memory_rdma: Bool32,
}

impl Default for PhysicalDeviceExternalMemoryRDMAFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV,
            next: ptr::null_mut(),
            external_memory_rdma: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalMemorySciBufFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExternalMemorySciBufFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub sci_buf_import: Bool32,
    pub sci_buf_export: Bool32,
}

impl Default for PhysicalDeviceExternalMemorySciBufFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV,
            next: ptr::null_mut(),
            sci_buf_import: Bool32::default(),
            sci_buf_export: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub screen_buffer_import: Bool32,
}

impl Default for PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX,
            next: ptr::null_mut(),
            screen_buffer_import: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalSciSync2FeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExternalSciSync2FeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub sci_sync_fence: Bool32,
    pub sci_sync_semaphore2: Bool32,
    pub sci_sync_import: Bool32,
    pub sci_sync_export: Bool32,
}

impl Default for PhysicalDeviceExternalSciSync2FeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_2_FEATURES_NV,
            next: ptr::null_mut(),
            sci_sync_fence: Bool32::default(),
            sci_sync_semaphore2: Bool32::default(),
            sci_sync_import: Bool32::default(),
            sci_sync_export: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalSciSyncFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExternalSciSyncFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub sci_sync_fence: Bool32,
    pub sci_sync_semaphore: Bool32,
    pub sci_sync_import: Bool32,
    pub sci_sync_export: Bool32,
}

impl Default for PhysicalDeviceExternalSciSyncFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_FEATURES_NV,
            next: ptr::null_mut(),
            sci_sync_fence: Bool32::default(),
            sci_sync_semaphore: Bool32::default(),
            sci_sync_import: Bool32::default(),
            sci_sync_export: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalSemaphoreInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceExternalSemaphoreInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
}

impl Default for PhysicalDeviceExternalSemaphoreInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
            next: ptr::null(),
            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFaultFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFaultFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub device_fault: Bool32,
    pub device_fault_vendor_binary: Bool32,
}

impl Default for PhysicalDeviceFaultFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FAULT_FEATURES_EXT,
            next: ptr::null_mut(),
            device_fault: Bool32::default(),
            device_fault_vendor_binary: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFeatures {
    pub robust_buffer_access: Bool32,
    pub full_draw_index_uint32: Bool32,
    pub image_cube_array: Bool32,
    pub independent_blend: Bool32,
    pub geometry_shader: Bool32,
    pub tessellation_shader: Bool32,
    pub sample_rate_shading: Bool32,
    pub dual_src_blend: Bool32,
    pub logic_op: Bool32,
    pub multi_draw_indirect: Bool32,
    pub draw_indirect_first_instance: Bool32,
    pub depth_clamp: Bool32,
    pub depth_bias_clamp: Bool32,
    pub fill_mode_non_solid: Bool32,
    pub depth_bounds: Bool32,
    pub wide_lines: Bool32,
    pub large_points: Bool32,
    pub alpha_to_one: Bool32,
    pub multi_viewport: Bool32,
    pub sampler_anisotropy: Bool32,
    pub texture_compression_etc2: Bool32,
    pub texture_compression_astc_ldr: Bool32,
    pub texture_compression_bc: Bool32,
    pub occlusion_query_precise: Bool32,
    pub pipeline_statistics_query: Bool32,
    pub vertex_pipeline_stores_and_atomics: Bool32,
    pub fragment_stores_and_atomics: Bool32,
    pub shader_tessellation_and_geometry_point_size: Bool32,
    pub shader_image_gather_extended: Bool32,
    pub shader_storage_image_extended_formats: Bool32,
    pub shader_storage_image_multisample: Bool32,
    pub shader_storage_image_read_without_format: Bool32,
    pub shader_storage_image_write_without_format: Bool32,
    pub shader_uniform_buffer_array_dynamic_indexing: Bool32,
    pub shader_sampled_image_array_dynamic_indexing: Bool32,
    pub shader_storage_buffer_array_dynamic_indexing: Bool32,
    pub shader_storage_image_array_dynamic_indexing: Bool32,
    pub shader_clip_distance: Bool32,
    pub shader_cull_distance: Bool32,
    pub shader_float64: Bool32,
    pub shader_int64: Bool32,
    pub shader_int16: Bool32,
    pub shader_resource_residency: Bool32,
    pub shader_resource_min_lod: Bool32,
    pub sparse_binding: Bool32,
    pub sparse_residency_buffer: Bool32,
    pub sparse_residency_image_2d: Bool32,
    pub sparse_residency_image_3d: Bool32,
    pub sparse_residency2_samples: Bool32,
    pub sparse_residency4_samples: Bool32,
    pub sparse_residency8_samples: Bool32,
    pub sparse_residency16_samples: Bool32,
    pub sparse_residency_aliased: Bool32,
    pub variable_multisample_rate: Bool32,
    pub inherited_queries: Bool32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFeatures2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFeatures2 {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub features: PhysicalDeviceFeatures,
}

impl Default for PhysicalDeviceFeatures2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FEATURES_2,
            next: ptr::null_mut(),
            features: PhysicalDeviceFeatures::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFloatControlsProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFloatControlsProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub denorm_behavior_independence: ShaderFloatControlsIndependence,
    pub rounding_mode_independence: ShaderFloatControlsIndependence,
    pub shader_signed_zero_inf_nan_preserve_float16: Bool32,
    pub shader_signed_zero_inf_nan_preserve_float32: Bool32,
    pub shader_signed_zero_inf_nan_preserve_float64: Bool32,
    pub shader_denorm_preserve_float16: Bool32,
    pub shader_denorm_preserve_float32: Bool32,
    pub shader_denorm_preserve_float64: Bool32,
    pub shader_denorm_flush_to_zero_float16: Bool32,
    pub shader_denorm_flush_to_zero_float32: Bool32,
    pub shader_denorm_flush_to_zero_float64: Bool32,
    pub shader_rounding_mode_rte_float16: Bool32,
    pub shader_rounding_mode_rte_float32: Bool32,
    pub shader_rounding_mode_rte_float64: Bool32,
    pub shader_rounding_mode_rtz_float16: Bool32,
    pub shader_rounding_mode_rtz_float32: Bool32,
    pub shader_rounding_mode_rtz_float64: Bool32,
}

impl Default for PhysicalDeviceFloatControlsProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
            next: ptr::null_mut(),
            denorm_behavior_independence: ShaderFloatControlsIndependence::default(),
            rounding_mode_independence: ShaderFloatControlsIndependence::default(),
            shader_signed_zero_inf_nan_preserve_float16: Bool32::default(),
            shader_signed_zero_inf_nan_preserve_float32: Bool32::default(),
            shader_signed_zero_inf_nan_preserve_float64: Bool32::default(),
            shader_denorm_preserve_float16: Bool32::default(),
            shader_denorm_preserve_float32: Bool32::default(),
            shader_denorm_preserve_float64: Bool32::default(),
            shader_denorm_flush_to_zero_float16: Bool32::default(),
            shader_denorm_flush_to_zero_float32: Bool32::default(),
            shader_denorm_flush_to_zero_float64: Bool32::default(),
            shader_rounding_mode_rte_float16: Bool32::default(),
            shader_rounding_mode_rte_float32: Bool32::default(),
            shader_rounding_mode_rte_float64: Bool32::default(),
            shader_rounding_mode_rtz_float16: Bool32::default(),
            shader_rounding_mode_rtz_float32: Bool32::default(),
            shader_rounding_mode_rtz_float64: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub fragment_density_map_deferred: Bool32,
}

impl Default for PhysicalDeviceFragmentDensityMap2FeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT,
            next: ptr::null_mut(),
            fragment_density_map_deferred: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub subsampled_loads: Bool32,
    pub subsampled_coarse_reconstruction_early_access: Bool32,
    pub max_subsampled_array_layers: u32,
    pub max_descriptor_set_subsampled_samplers: u32,
}

impl Default for PhysicalDeviceFragmentDensityMap2PropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT,
            next: ptr::null_mut(),
            subsampled_loads: Bool32::default(),
            subsampled_coarse_reconstruction_early_access: Bool32::default(),
            max_subsampled_array_layers: u32::default(),
            max_descriptor_set_subsampled_samplers: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub fragment_density_map: Bool32,
    pub fragment_density_map_dynamic: Bool32,
    pub fragment_density_map_non_subsampled_images: Bool32,
}

impl Default for PhysicalDeviceFragmentDensityMapFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT,
            next: ptr::null_mut(),
            fragment_density_map: Bool32::default(),
            fragment_density_map_dynamic: Bool32::default(),
            fragment_density_map_non_subsampled_images: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub fragment_density_map_offset: Bool32,
}

impl Default for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM,
            next: ptr::null_mut(),
            fragment_density_map_offset: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub fragment_density_offset_granularity: Extent2D,
}

impl Default for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM,
            next: ptr::null_mut(),
            fragment_density_offset_granularity: Extent2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub min_fragment_density_texel_size: Extent2D,
    pub max_fragment_density_texel_size: Extent2D,
    pub fragment_density_invocations: Bool32,
}

impl Default for PhysicalDeviceFragmentDensityMapPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT,
            next: ptr::null_mut(),
            min_fragment_density_texel_size: Extent2D::default(),
            max_fragment_density_texel_size: Extent2D::default(),
            fragment_density_invocations: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub fragment_shader_barycentric: Bool32,
}

impl Default for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR,
            next: ptr::null_mut(),
            fragment_shader_barycentric: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub tri_strip_vertex_order_independent_of_provoking_vertex: Bool32,
}

impl Default for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR,
            next: ptr::null_mut(),
            tri_strip_vertex_order_independent_of_provoking_vertex: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub fragment_shader_sample_interlock: Bool32,
    pub fragment_shader_pixel_interlock: Bool32,
    pub fragment_shader_shading_rate_interlock: Bool32,
}

impl Default for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT,
            next: ptr::null_mut(),
            fragment_shader_sample_interlock: Bool32::default(),
            fragment_shader_pixel_interlock: Bool32::default(),
            fragment_shader_shading_rate_interlock: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub fragment_shading_rate_enums: Bool32,
    pub supersample_fragment_shading_rates: Bool32,
    pub no_invocation_fragment_shading_rates: Bool32,
}

impl Default for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV,
            next: ptr::null_mut(),
            fragment_shading_rate_enums: Bool32::default(),
            supersample_fragment_shading_rates: Bool32::default(),
            no_invocation_fragment_shading_rates: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_fragment_shading_rate_invocation_count: SampleCountFlags,
}

impl Default for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV,
            next: ptr::null_mut(),
            max_fragment_shading_rate_invocation_count: SampleCountFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShadingRateFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFragmentShadingRateFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pipeline_fragment_shading_rate: Bool32,
    pub primitive_fragment_shading_rate: Bool32,
    pub attachment_fragment_shading_rate: Bool32,
}

impl Default for PhysicalDeviceFragmentShadingRateFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR,
            next: ptr::null_mut(),
            pipeline_fragment_shading_rate: Bool32::default(),
            primitive_fragment_shading_rate: Bool32::default(),
            attachment_fragment_shading_rate: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShadingRateKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFragmentShadingRateKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub sample_counts: SampleCountFlags,
    pub fragment_size: Extent2D,
}

impl Default for PhysicalDeviceFragmentShadingRateKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR,
            next: ptr::null_mut(),
            sample_counts: SampleCountFlags::default(),
            fragment_size: Extent2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFragmentShadingRatePropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub min_fragment_shading_rate_attachment_texel_size: Extent2D,
    pub max_fragment_shading_rate_attachment_texel_size: Extent2D,
    pub max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32,
    pub primitive_fragment_shading_rate_with_multiple_viewports: Bool32,
    pub layered_shading_rate_attachments: Bool32,
    pub fragment_shading_rate_non_trivial_combiner_ops: Bool32,
    pub max_fragment_size: Extent2D,
    pub max_fragment_size_aspect_ratio: u32,
    pub max_fragment_shading_rate_coverage_samples: u32,
    pub max_fragment_shading_rate_rasterization_samples: SampleCountFlags,
    pub fragment_shading_rate_with_shader_depth_stencil_writes: Bool32,
    pub fragment_shading_rate_with_sample_mask: Bool32,
    pub fragment_shading_rate_with_shader_sample_mask: Bool32,
    pub fragment_shading_rate_with_conservative_rasterization: Bool32,
    pub fragment_shading_rate_with_fragment_shader_interlock: Bool32,
    pub fragment_shading_rate_with_custom_sample_locations: Bool32,
    pub fragment_shading_rate_strict_multiply_combiner: Bool32,
}

impl Default for PhysicalDeviceFragmentShadingRatePropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR,
            next: ptr::null_mut(),
            min_fragment_shading_rate_attachment_texel_size: Extent2D::default(),
            max_fragment_shading_rate_attachment_texel_size: Extent2D::default(),
            max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32::default(),
            primitive_fragment_shading_rate_with_multiple_viewports: Bool32::default(),
            layered_shading_rate_attachments: Bool32::default(),
            fragment_shading_rate_non_trivial_combiner_ops: Bool32::default(),
            max_fragment_size: Extent2D::default(),
            max_fragment_size_aspect_ratio: u32::default(),
            max_fragment_shading_rate_coverage_samples: u32::default(),
            max_fragment_shading_rate_rasterization_samples: SampleCountFlags::default(),
            fragment_shading_rate_with_shader_depth_stencil_writes: Bool32::default(),
            fragment_shading_rate_with_sample_mask: Bool32::default(),
            fragment_shading_rate_with_shader_sample_mask: Bool32::default(),
            fragment_shading_rate_with_conservative_rasterization: Bool32::default(),
            fragment_shading_rate_with_fragment_shader_interlock: Bool32::default(),
            fragment_shading_rate_with_custom_sample_locations: Bool32::default(),
            fragment_shading_rate_strict_multiply_combiner: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFrameBoundaryFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceFrameBoundaryFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub frame_boundary: Bool32,
}

impl Default for PhysicalDeviceFrameBoundaryFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT,
            next: ptr::null_mut(),
            frame_boundary: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceGlobalPriorityQueryFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceGlobalPriorityQueryFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub global_priority_query: Bool32,
}

impl Default for PhysicalDeviceGlobalPriorityQueryFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES,
            next: ptr::null_mut(),
            global_priority_query: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub graphics_pipeline_library: Bool32,
}

impl Default for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT,
            next: ptr::null_mut(),
            graphics_pipeline_library: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub graphics_pipeline_library_fast_linking: Bool32,
    pub graphics_pipeline_library_independent_interpolation_decoration: Bool32,
}

impl Default for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT,
            next: ptr::null_mut(),
            graphics_pipeline_library_fast_linking: Bool32::default(),
            graphics_pipeline_library_independent_interpolation_decoration: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceGroupProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceGroupProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub physical_device_count: u32,
    pub physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE],
    pub subset_allocation: Bool32,
}

impl Default for PhysicalDeviceGroupProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_GROUP_PROPERTIES,
            next: ptr::null_mut(),
            physical_device_count: u32::default(),
            physical_devices: [PhysicalDevice::default(); MAX_DEVICE_GROUP_SIZE],
            subset_allocation: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceHdrVividFeaturesHUAWEI.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceHdrVividFeaturesHUAWEI {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub hdr_vivid: Bool32,
}

impl Default for PhysicalDeviceHdrVividFeaturesHUAWEI {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI,
            next: ptr::null_mut(),
            hdr_vivid: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceHostImageCopyFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceHostImageCopyFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub host_image_copy: Bool32,
}

impl Default for PhysicalDeviceHostImageCopyFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES,
            next: ptr::null_mut(),
            host_image_copy: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceHostImageCopyProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceHostImageCopyProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub copy_src_layout_count: u32,
    pub copy_src_layouts: *mut ImageLayout,
    pub copy_dst_layout_count: u32,
    pub copy_dst_layouts: *mut ImageLayout,
    pub optimal_tiling_layout_uuid: ByteArray<UUID_SIZE>,
    pub identical_memory_type_requirements: Bool32,
}

impl Default for PhysicalDeviceHostImageCopyProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES,
            next: ptr::null_mut(),
            copy_src_layout_count: u32::default(),
            copy_src_layouts: ptr::null_mut(),
            copy_dst_layout_count: u32::default(),
            copy_dst_layouts: ptr::null_mut(),
            optimal_tiling_layout_uuid: ByteArray::default(),
            identical_memory_type_requirements: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceHostQueryResetFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceHostQueryResetFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub host_query_reset: Bool32,
}

impl Default for PhysicalDeviceHostQueryResetFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
            next: ptr::null_mut(),
            host_query_reset: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceIDProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceIDProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub device_uuid: ByteArray<UUID_SIZE>,
    pub driver_uuid: ByteArray<UUID_SIZE>,
    pub device_luid: ByteArray<LUID_SIZE>,
    pub device_node_mask: u32,
    pub device_luid_valid: Bool32,
}

impl Default for PhysicalDeviceIDProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_ID_PROPERTIES,
            next: ptr::null_mut(),
            device_uuid: ByteArray::default(),
            driver_uuid: ByteArray::default(),
            device_luid: ByteArray::default(),
            device_node_mask: u32::default(),
            device_luid_valid: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceImage2DViewOf3DFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub image_2d_view_of_3d: Bool32,
    pub sampler_2d_view_of_3d: Bool32,
}

impl Default for PhysicalDeviceImage2DViewOf3DFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT,
            next: ptr::null_mut(),
            image_2d_view_of_3d: Bool32::default(),
            sampler_2d_view_of_3d: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImageAlignmentControlFeaturesMESA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceImageAlignmentControlFeaturesMESA {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub image_alignment_control: Bool32,
}

impl Default for PhysicalDeviceImageAlignmentControlFeaturesMESA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA,
            next: ptr::null_mut(),
            image_alignment_control: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImageAlignmentControlPropertiesMESA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceImageAlignmentControlPropertiesMESA {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub supported_image_alignment_mask: u32,
}

impl Default for PhysicalDeviceImageAlignmentControlPropertiesMESA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA,
            next: ptr::null_mut(),
            supported_image_alignment_mask: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImageCompressionControlFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceImageCompressionControlFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub image_compression_control: Bool32,
}

impl Default for PhysicalDeviceImageCompressionControlFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT,
            next: ptr::null_mut(),
            image_compression_control: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub image_compression_control_swapchain: Bool32,
}

impl Default for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT,
            next: ptr::null_mut(),
            image_compression_control_swapchain: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImageDrmFormatModifierInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceImageDrmFormatModifierInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub drm_format_modifier: u64,
    pub sharing_mode: SharingMode,
    pub queue_family_index_count: u32,
    pub queue_family_indices: *const u32,
}

impl Default for PhysicalDeviceImageDrmFormatModifierInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
            next: ptr::null(),
            drm_format_modifier: u64::default(),
            sharing_mode: SharingMode::default(),
            queue_family_index_count: u32::default(),
            queue_family_indices: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImageFormatInfo2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceImageFormatInfo2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub format: Format,
    pub type_: ImageType,
    pub tiling: ImageTiling,
    pub usage: ImageUsageFlags,
    pub flags: ImageCreateFlags,
}

impl Default for PhysicalDeviceImageFormatInfo2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
            next: ptr::null(),
            format: Format::default(),
            type_: ImageType::default(),
            tiling: ImageTiling::default(),
            usage: ImageUsageFlags::default(),
            flags: ImageCreateFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImageProcessing2FeaturesQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceImageProcessing2FeaturesQCOM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub texture_block_match2: Bool32,
}

impl Default for PhysicalDeviceImageProcessing2FeaturesQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM,
            next: ptr::null_mut(),
            texture_block_match2: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImageProcessing2PropertiesQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceImageProcessing2PropertiesQCOM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_block_match_window: Extent2D,
}

impl Default for PhysicalDeviceImageProcessing2PropertiesQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM,
            next: ptr::null_mut(),
            max_block_match_window: Extent2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImageProcessingFeaturesQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceImageProcessingFeaturesQCOM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub texture_sample_weighted: Bool32,
    pub texture_box_filter: Bool32,
    pub texture_block_match: Bool32,
}

impl Default for PhysicalDeviceImageProcessingFeaturesQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM,
            next: ptr::null_mut(),
            texture_sample_weighted: Bool32::default(),
            texture_box_filter: Bool32::default(),
            texture_block_match: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImageProcessingPropertiesQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceImageProcessingPropertiesQCOM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_weight_filter_phases: u32,
    pub max_weight_filter_dimension: Extent2D,
    pub max_block_match_region: Extent2D,
    pub max_box_filter_block_size: Extent2D,
}

impl Default for PhysicalDeviceImageProcessingPropertiesQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM,
            next: ptr::null_mut(),
            max_weight_filter_phases: u32::default(),
            max_weight_filter_dimension: Extent2D::default(),
            max_block_match_region: Extent2D::default(),
            max_box_filter_block_size: Extent2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImageRobustnessFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceImageRobustnessFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub robust_image_access: Bool32,
}

impl Default for PhysicalDeviceImageRobustnessFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES,
            next: ptr::null_mut(),
            robust_image_access: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub image_sliced_view_of_3d: Bool32,
}

impl Default for PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT,
            next: ptr::null_mut(),
            image_sliced_view_of_3d: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImageViewImageFormatInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceImageViewImageFormatInfoEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub image_view_type: ImageViewType,
}

impl Default for PhysicalDeviceImageViewImageFormatInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT,
            next: ptr::null_mut(),
            image_view_type: ImageViewType::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImageViewMinLodFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceImageViewMinLodFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub min_lod: Bool32,
}

impl Default for PhysicalDeviceImageViewMinLodFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT,
            next: ptr::null_mut(),
            min_lod: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImagelessFramebufferFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceImagelessFramebufferFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub imageless_framebuffer: Bool32,
}

impl Default for PhysicalDeviceImagelessFramebufferFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES,
            next: ptr::null_mut(),
            imageless_framebuffer: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceIndexTypeUint8Features.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceIndexTypeUint8Features {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub index_type_uint8: Bool32,
}

impl Default for PhysicalDeviceIndexTypeUint8Features {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES,
            next: ptr::null_mut(),
            index_type_uint8: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceInheritedViewportScissorFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceInheritedViewportScissorFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub inherited_viewport_scissor_2d: Bool32,
}

impl Default for PhysicalDeviceInheritedViewportScissorFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV,
            next: ptr::null_mut(),
            inherited_viewport_scissor_2d: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceInlineUniformBlockFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceInlineUniformBlockFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub inline_uniform_block: Bool32,
    pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32,
}

impl Default for PhysicalDeviceInlineUniformBlockFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES,
            next: ptr::null_mut(),
            inline_uniform_block: Bool32::default(),
            descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceInlineUniformBlockProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceInlineUniformBlockProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_inline_uniform_block_size: u32,
    pub max_per_stage_descriptor_inline_uniform_blocks: u32,
    pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
    pub max_descriptor_set_inline_uniform_blocks: u32,
    pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
}

impl Default for PhysicalDeviceInlineUniformBlockProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES,
            next: ptr::null_mut(),
            max_inline_uniform_block_size: u32::default(),
            max_per_stage_descriptor_inline_uniform_blocks: u32::default(),
            max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32::default(),
            max_descriptor_set_inline_uniform_blocks: u32::default(),
            max_descriptor_set_update_after_bind_inline_uniform_blocks: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEI {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub invocation_mask: Bool32,
}

impl Default for PhysicalDeviceInvocationMaskFeaturesHUAWEI {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI,
            next: ptr::null_mut(),
            invocation_mask: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceLayeredApiPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceLayeredApiPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub vendor_id: u32,
    pub device_id: u32,
    pub layered_api: PhysicalDeviceLayeredApiKHR,
    pub device_name: StringArray<MAX_PHYSICAL_DEVICE_NAME_SIZE>,
}

impl Default for PhysicalDeviceLayeredApiPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR,
            next: ptr::null_mut(),
            vendor_id: u32::default(),
            device_id: u32::default(),
            layered_api: PhysicalDeviceLayeredApiKHR::default(),
            device_name: StringArray::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceLayeredApiPropertiesListKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceLayeredApiPropertiesListKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub layered_api_count: u32,
    pub layered_apis: *mut PhysicalDeviceLayeredApiPropertiesKHR,
}

impl Default for PhysicalDeviceLayeredApiPropertiesListKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR,
            next: ptr::null_mut(),
            layered_api_count: u32::default(),
            layered_apis: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceLayeredApiVulkanPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct PhysicalDeviceLayeredApiVulkanPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub properties: PhysicalDeviceProperties2,
}

impl Default for PhysicalDeviceLayeredApiVulkanPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR,
            next: ptr::null_mut(),
            properties: PhysicalDeviceProperties2::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceLayeredDriverPropertiesMSFT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceLayeredDriverPropertiesMSFT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub underlying_api: LayeredDriverUnderlyingApiMSFT,
}

impl Default for PhysicalDeviceLayeredDriverPropertiesMSFT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT,
            next: ptr::null_mut(),
            underlying_api: LayeredDriverUnderlyingApiMSFT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceLegacyDitheringFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceLegacyDitheringFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub legacy_dithering: Bool32,
}

impl Default for PhysicalDeviceLegacyDitheringFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT,
            next: ptr::null_mut(),
            legacy_dithering: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceLegacyVertexAttributesFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub legacy_vertex_attributes: Bool32,
}

impl Default for PhysicalDeviceLegacyVertexAttributesFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT,
            next: ptr::null_mut(),
            legacy_vertex_attributes: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceLegacyVertexAttributesPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub native_unaligned_performance: Bool32,
}

impl Default for PhysicalDeviceLegacyVertexAttributesPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT,
            next: ptr::null_mut(),
            native_unaligned_performance: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceLimits.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq)]
pub struct PhysicalDeviceLimits {
    pub max_image_dimension_1d: u32,
    pub max_image_dimension_2d: u32,
    pub max_image_dimension_3d: u32,
    pub max_image_dimension_cube: u32,
    pub max_image_array_layers: u32,
    pub max_texel_buffer_elements: u32,
    pub max_uniform_buffer_range: u32,
    pub max_storage_buffer_range: u32,
    pub max_push_constants_size: u32,
    pub max_memory_allocation_count: u32,
    pub max_sampler_allocation_count: u32,
    pub buffer_image_granularity: DeviceSize,
    pub sparse_address_space_size: DeviceSize,
    pub max_bound_descriptor_sets: u32,
    pub max_per_stage_descriptor_samplers: u32,
    pub max_per_stage_descriptor_uniform_buffers: u32,
    pub max_per_stage_descriptor_storage_buffers: u32,
    pub max_per_stage_descriptor_sampled_images: u32,
    pub max_per_stage_descriptor_storage_images: u32,
    pub max_per_stage_descriptor_input_attachments: u32,
    pub max_per_stage_resources: u32,
    pub max_descriptor_set_samplers: u32,
    pub max_descriptor_set_uniform_buffers: u32,
    pub max_descriptor_set_uniform_buffers_dynamic: u32,
    pub max_descriptor_set_storage_buffers: u32,
    pub max_descriptor_set_storage_buffers_dynamic: u32,
    pub max_descriptor_set_sampled_images: u32,
    pub max_descriptor_set_storage_images: u32,
    pub max_descriptor_set_input_attachments: u32,
    pub max_vertex_input_attributes: u32,
    pub max_vertex_input_bindings: u32,
    pub max_vertex_input_attribute_offset: u32,
    pub max_vertex_input_binding_stride: u32,
    pub max_vertex_output_components: u32,
    pub max_tessellation_generation_level: u32,
    pub max_tessellation_patch_size: u32,
    pub max_tessellation_control_per_vertex_input_components: u32,
    pub max_tessellation_control_per_vertex_output_components: u32,
    pub max_tessellation_control_per_patch_output_components: u32,
    pub max_tessellation_control_total_output_components: u32,
    pub max_tessellation_evaluation_input_components: u32,
    pub max_tessellation_evaluation_output_components: u32,
    pub max_geometry_shader_invocations: u32,
    pub max_geometry_input_components: u32,
    pub max_geometry_output_components: u32,
    pub max_geometry_output_vertices: u32,
    pub max_geometry_total_output_components: u32,
    pub max_fragment_input_components: u32,
    pub max_fragment_output_attachments: u32,
    pub max_fragment_dual_src_attachments: u32,
    pub max_fragment_combined_output_resources: u32,
    pub max_compute_shared_memory_size: u32,
    pub max_compute_work_group_count: [u32; 3],
    pub max_compute_work_group_invocations: u32,
    pub max_compute_work_group_size: [u32; 3],
    pub sub_pixel_precision_bits: u32,
    pub sub_texel_precision_bits: u32,
    pub mipmap_precision_bits: u32,
    pub max_draw_indexed_index_value: u32,
    pub max_draw_indirect_count: u32,
    pub max_sampler_lod_bias: f32,
    pub max_sampler_anisotropy: f32,
    pub max_viewports: u32,
    pub max_viewport_dimensions: [u32; 2],
    pub viewport_bounds_range: [f32; 2],
    pub viewport_sub_pixel_bits: u32,
    pub min_memory_map_alignment: usize,
    pub min_texel_buffer_offset_alignment: DeviceSize,
    pub min_uniform_buffer_offset_alignment: DeviceSize,
    pub min_storage_buffer_offset_alignment: DeviceSize,
    pub min_texel_offset: i32,
    pub max_texel_offset: u32,
    pub min_texel_gather_offset: i32,
    pub max_texel_gather_offset: u32,
    pub min_interpolation_offset: f32,
    pub max_interpolation_offset: f32,
    pub sub_pixel_interpolation_offset_bits: u32,
    pub max_framebuffer_width: u32,
    pub max_framebuffer_height: u32,
    pub max_framebuffer_layers: u32,
    pub framebuffer_color_sample_counts: SampleCountFlags,
    pub framebuffer_depth_sample_counts: SampleCountFlags,
    pub framebuffer_stencil_sample_counts: SampleCountFlags,
    pub framebuffer_no_attachments_sample_counts: SampleCountFlags,
    pub max_color_attachments: u32,
    pub sampled_image_color_sample_counts: SampleCountFlags,
    pub sampled_image_integer_sample_counts: SampleCountFlags,
    pub sampled_image_depth_sample_counts: SampleCountFlags,
    pub sampled_image_stencil_sample_counts: SampleCountFlags,
    pub storage_image_sample_counts: SampleCountFlags,
    pub max_sample_mask_words: u32,
    pub timestamp_compute_and_graphics: Bool32,
    pub timestamp_period: f32,
    pub max_clip_distances: u32,
    pub max_cull_distances: u32,
    pub max_combined_clip_and_cull_distances: u32,
    pub discrete_queue_priorities: u32,
    pub point_size_range: [f32; 2],
    pub line_width_range: [f32; 2],
    pub point_size_granularity: f32,
    pub line_width_granularity: f32,
    pub strict_lines: Bool32,
    pub standard_sample_locations: Bool32,
    pub optimal_buffer_copy_offset_alignment: DeviceSize,
    pub optimal_buffer_copy_row_pitch_alignment: DeviceSize,
    pub non_coherent_atom_size: DeviceSize,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceLineRasterizationFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceLineRasterizationFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub rectangular_lines: Bool32,
    pub bresenham_lines: Bool32,
    pub smooth_lines: Bool32,
    pub stippled_rectangular_lines: Bool32,
    pub stippled_bresenham_lines: Bool32,
    pub stippled_smooth_lines: Bool32,
}

impl Default for PhysicalDeviceLineRasterizationFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES,
            next: ptr::null_mut(),
            rectangular_lines: Bool32::default(),
            bresenham_lines: Bool32::default(),
            smooth_lines: Bool32::default(),
            stippled_rectangular_lines: Bool32::default(),
            stippled_bresenham_lines: Bool32::default(),
            stippled_smooth_lines: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceLineRasterizationProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceLineRasterizationProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub line_sub_pixel_precision_bits: u32,
}

impl Default for PhysicalDeviceLineRasterizationProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES,
            next: ptr::null_mut(),
            line_sub_pixel_precision_bits: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceLinearColorAttachmentFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceLinearColorAttachmentFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub linear_color_attachment: Bool32,
}

impl Default for PhysicalDeviceLinearColorAttachmentFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV,
            next: ptr::null_mut(),
            linear_color_attachment: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance3Properties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMaintenance3Properties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_per_set_descriptors: u32,
    pub max_memory_allocation_size: DeviceSize,
}

impl Default for PhysicalDeviceMaintenance3Properties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
            next: ptr::null_mut(),
            max_per_set_descriptors: u32::default(),
            max_memory_allocation_size: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance4Features.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMaintenance4Features {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub maintenance4: Bool32,
}

impl Default for PhysicalDeviceMaintenance4Features {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES,
            next: ptr::null_mut(),
            maintenance4: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance4Properties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMaintenance4Properties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_buffer_size: DeviceSize,
}

impl Default for PhysicalDeviceMaintenance4Properties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES,
            next: ptr::null_mut(),
            max_buffer_size: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance5Features.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMaintenance5Features {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub maintenance5: Bool32,
}

impl Default for PhysicalDeviceMaintenance5Features {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES,
            next: ptr::null_mut(),
            maintenance5: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance5Properties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMaintenance5Properties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub early_fragment_multisample_coverage_after_sample_counting: Bool32,
    pub early_fragment_sample_mask_test_before_sample_counting: Bool32,
    pub depth_stencil_swizzle_one_support: Bool32,
    pub polygon_mode_point_size: Bool32,
    pub non_strict_single_pixel_wide_lines_use_parallelogram: Bool32,
    pub non_strict_wide_lines_use_parallelogram: Bool32,
}

impl Default for PhysicalDeviceMaintenance5Properties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES,
            next: ptr::null_mut(),
            early_fragment_multisample_coverage_after_sample_counting: Bool32::default(),
            early_fragment_sample_mask_test_before_sample_counting: Bool32::default(),
            depth_stencil_swizzle_one_support: Bool32::default(),
            polygon_mode_point_size: Bool32::default(),
            non_strict_single_pixel_wide_lines_use_parallelogram: Bool32::default(),
            non_strict_wide_lines_use_parallelogram: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance6Features.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMaintenance6Features {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub maintenance6: Bool32,
}

impl Default for PhysicalDeviceMaintenance6Features {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES,
            next: ptr::null_mut(),
            maintenance6: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance6Properties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMaintenance6Properties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub block_texel_view_compatible_multiple_layers: Bool32,
    pub max_combined_image_sampler_descriptor_count: u32,
    pub fragment_shading_rate_clamp_combiner_inputs: Bool32,
}

impl Default for PhysicalDeviceMaintenance6Properties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES,
            next: ptr::null_mut(),
            block_texel_view_compatible_multiple_layers: Bool32::default(),
            max_combined_image_sampler_descriptor_count: u32::default(),
            fragment_shading_rate_clamp_combiner_inputs: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance7FeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMaintenance7FeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub maintenance7: Bool32,
}

impl Default for PhysicalDeviceMaintenance7FeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR,
            next: ptr::null_mut(),
            maintenance7: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance7PropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMaintenance7PropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub robust_fragment_shading_rate_attachment_access: Bool32,
    pub separate_depth_stencil_attachment_access: Bool32,
    pub max_descriptor_set_total_uniform_buffers_dynamic: u32,
    pub max_descriptor_set_total_storage_buffers_dynamic: u32,
    pub max_descriptor_set_total_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_total_uniform_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_total_storage_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_total_buffers_dynamic: u32,
}

impl Default for PhysicalDeviceMaintenance7PropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR,
            next: ptr::null_mut(),
            robust_fragment_shading_rate_attachment_access: Bool32::default(),
            separate_depth_stencil_attachment_access: Bool32::default(),
            max_descriptor_set_total_uniform_buffers_dynamic: u32::default(),
            max_descriptor_set_total_storage_buffers_dynamic: u32::default(),
            max_descriptor_set_total_buffers_dynamic: u32::default(),
            max_descriptor_set_update_after_bind_total_uniform_buffers_dynamic: u32::default(),
            max_descriptor_set_update_after_bind_total_storage_buffers_dynamic: u32::default(),
            max_descriptor_set_update_after_bind_total_buffers_dynamic: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance8FeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMaintenance8FeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub maintenance8: Bool32,
}

impl Default for PhysicalDeviceMaintenance8FeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR,
            next: ptr::null_mut(),
            maintenance8: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMapMemoryPlacedFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMapMemoryPlacedFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub memory_map_placed: Bool32,
    pub memory_map_range_placed: Bool32,
    pub memory_unmap_reserve: Bool32,
}

impl Default for PhysicalDeviceMapMemoryPlacedFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT,
            next: ptr::null_mut(),
            memory_map_placed: Bool32::default(),
            memory_map_range_placed: Bool32::default(),
            memory_unmap_reserve: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMapMemoryPlacedPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMapMemoryPlacedPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub min_placed_memory_map_alignment: DeviceSize,
}

impl Default for PhysicalDeviceMapMemoryPlacedPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT,
            next: ptr::null_mut(),
            min_placed_memory_map_alignment: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryBudgetPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMemoryBudgetPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub heap_budget: [DeviceSize; MAX_MEMORY_HEAPS],
    pub heap_usage: [DeviceSize; MAX_MEMORY_HEAPS],
}

impl Default for PhysicalDeviceMemoryBudgetPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT,
            next: ptr::null_mut(),
            heap_budget: [DeviceSize::default(); MAX_MEMORY_HEAPS],
            heap_usage: [DeviceSize::default(); MAX_MEMORY_HEAPS],
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryDecompressionFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMemoryDecompressionFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub memory_decompression: Bool32,
}

impl Default for PhysicalDeviceMemoryDecompressionFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV,
            next: ptr::null_mut(),
            memory_decompression: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryDecompressionPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMemoryDecompressionPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub decompression_methods: MemoryDecompressionMethodFlagsNV,
    pub max_decompression_indirect_count: u64,
}

impl Default for PhysicalDeviceMemoryDecompressionPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV,
            next: ptr::null_mut(),
            decompression_methods: MemoryDecompressionMethodFlagsNV::default(),
            max_decompression_indirect_count: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryPriorityFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMemoryPriorityFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub memory_priority: Bool32,
}

impl Default for PhysicalDeviceMemoryPriorityFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT,
            next: ptr::null_mut(),
            memory_priority: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMemoryProperties {
    pub memory_type_count: u32,
    pub memory_types: [MemoryType; MAX_MEMORY_TYPES],
    pub memory_heap_count: u32,
    pub memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS],
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryProperties2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMemoryProperties2 {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub memory_properties: PhysicalDeviceMemoryProperties,
}

impl Default for PhysicalDeviceMemoryProperties2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
            next: ptr::null_mut(),
            memory_properties: PhysicalDeviceMemoryProperties::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMeshShaderFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMeshShaderFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub task_shader: Bool32,
    pub mesh_shader: Bool32,
    pub multiview_mesh_shader: Bool32,
    pub primitive_fragment_shading_rate_mesh_shader: Bool32,
    pub mesh_shader_queries: Bool32,
}

impl Default for PhysicalDeviceMeshShaderFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT,
            next: ptr::null_mut(),
            task_shader: Bool32::default(),
            mesh_shader: Bool32::default(),
            multiview_mesh_shader: Bool32::default(),
            primitive_fragment_shading_rate_mesh_shader: Bool32::default(),
            mesh_shader_queries: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMeshShaderFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMeshShaderFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub task_shader: Bool32,
    pub mesh_shader: Bool32,
}

impl Default for PhysicalDeviceMeshShaderFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV,
            next: ptr::null_mut(),
            task_shader: Bool32::default(),
            mesh_shader: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMeshShaderPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMeshShaderPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_task_work_group_total_count: u32,
    pub max_task_work_group_count: [u32; 3],
    pub max_task_work_group_invocations: u32,
    pub max_task_work_group_size: [u32; 3],
    pub max_task_payload_size: u32,
    pub max_task_shared_memory_size: u32,
    pub max_task_payload_and_shared_memory_size: u32,
    pub max_mesh_work_group_total_count: u32,
    pub max_mesh_work_group_count: [u32; 3],
    pub max_mesh_work_group_invocations: u32,
    pub max_mesh_work_group_size: [u32; 3],
    pub max_mesh_shared_memory_size: u32,
    pub max_mesh_payload_and_shared_memory_size: u32,
    pub max_mesh_output_memory_size: u32,
    pub max_mesh_payload_and_output_memory_size: u32,
    pub max_mesh_output_components: u32,
    pub max_mesh_output_vertices: u32,
    pub max_mesh_output_primitives: u32,
    pub max_mesh_output_layers: u32,
    pub max_mesh_multiview_view_count: u32,
    pub mesh_output_per_vertex_granularity: u32,
    pub mesh_output_per_primitive_granularity: u32,
    pub max_preferred_task_work_group_invocations: u32,
    pub max_preferred_mesh_work_group_invocations: u32,
    pub prefers_local_invocation_vertex_output: Bool32,
    pub prefers_local_invocation_primitive_output: Bool32,
    pub prefers_compact_vertex_output: Bool32,
    pub prefers_compact_primitive_output: Bool32,
}

impl Default for PhysicalDeviceMeshShaderPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT,
            next: ptr::null_mut(),
            max_task_work_group_total_count: u32::default(),
            max_task_work_group_count: [u32::default(); 3],
            max_task_work_group_invocations: u32::default(),
            max_task_work_group_size: [u32::default(); 3],
            max_task_payload_size: u32::default(),
            max_task_shared_memory_size: u32::default(),
            max_task_payload_and_shared_memory_size: u32::default(),
            max_mesh_work_group_total_count: u32::default(),
            max_mesh_work_group_count: [u32::default(); 3],
            max_mesh_work_group_invocations: u32::default(),
            max_mesh_work_group_size: [u32::default(); 3],
            max_mesh_shared_memory_size: u32::default(),
            max_mesh_payload_and_shared_memory_size: u32::default(),
            max_mesh_output_memory_size: u32::default(),
            max_mesh_payload_and_output_memory_size: u32::default(),
            max_mesh_output_components: u32::default(),
            max_mesh_output_vertices: u32::default(),
            max_mesh_output_primitives: u32::default(),
            max_mesh_output_layers: u32::default(),
            max_mesh_multiview_view_count: u32::default(),
            mesh_output_per_vertex_granularity: u32::default(),
            mesh_output_per_primitive_granularity: u32::default(),
            max_preferred_task_work_group_invocations: u32::default(),
            max_preferred_mesh_work_group_invocations: u32::default(),
            prefers_local_invocation_vertex_output: Bool32::default(),
            prefers_local_invocation_primitive_output: Bool32::default(),
            prefers_compact_vertex_output: Bool32::default(),
            prefers_compact_primitive_output: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMeshShaderPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_draw_mesh_tasks_count: u32,
    pub max_task_work_group_invocations: u32,
    pub max_task_work_group_size: [u32; 3],
    pub max_task_total_memory_size: u32,
    pub max_task_output_count: u32,
    pub max_mesh_work_group_invocations: u32,
    pub max_mesh_work_group_size: [u32; 3],
    pub max_mesh_total_memory_size: u32,
    pub max_mesh_output_vertices: u32,
    pub max_mesh_output_primitives: u32,
    pub max_mesh_multiview_view_count: u32,
    pub mesh_output_per_vertex_granularity: u32,
    pub mesh_output_per_primitive_granularity: u32,
}

impl Default for PhysicalDeviceMeshShaderPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV,
            next: ptr::null_mut(),
            max_draw_mesh_tasks_count: u32::default(),
            max_task_work_group_invocations: u32::default(),
            max_task_work_group_size: [u32::default(); 3],
            max_task_total_memory_size: u32::default(),
            max_task_output_count: u32::default(),
            max_mesh_work_group_invocations: u32::default(),
            max_mesh_work_group_size: [u32::default(); 3],
            max_mesh_total_memory_size: u32::default(),
            max_mesh_output_vertices: u32::default(),
            max_mesh_output_primitives: u32::default(),
            max_mesh_multiview_view_count: u32::default(),
            mesh_output_per_vertex_granularity: u32::default(),
            mesh_output_per_primitive_granularity: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiDrawFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMultiDrawFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub multi_draw: Bool32,
}

impl Default for PhysicalDeviceMultiDrawFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT,
            next: ptr::null_mut(),
            multi_draw: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiDrawPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMultiDrawPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_multi_draw_count: u32,
}

impl Default for PhysicalDeviceMultiDrawPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT,
            next: ptr::null_mut(),
            max_multi_draw_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub multisampled_render_to_single_sampled: Bool32,
}

impl Default for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type:
                StructureType::PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT,
            next: ptr::null_mut(),
            multisampled_render_to_single_sampled: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMultiviewFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub multiview: Bool32,
    pub multiview_geometry_shader: Bool32,
    pub multiview_tessellation_shader: Bool32,
}

impl Default for PhysicalDeviceMultiviewFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
            next: ptr::null_mut(),
            multiview: Bool32::default(),
            multiview_geometry_shader: Bool32::default(),
            multiview_tessellation_shader: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub per_view_position_all_components: Bool32,
}

impl Default for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX,
            next: ptr::null_mut(),
            per_view_position_all_components: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub multiview_per_view_render_areas: Bool32,
}

impl Default for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM,
            next: ptr::null_mut(),
            multiview_per_view_render_areas: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub multiview_per_view_viewports: Bool32,
}

impl Default for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM,
            next: ptr::null_mut(),
            multiview_per_view_viewports: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMultiviewProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_multiview_view_count: u32,
    pub max_multiview_instance_index: u32,
}

impl Default for PhysicalDeviceMultiviewProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
            next: ptr::null_mut(),
            max_multiview_view_count: u32::default(),
            max_multiview_instance_index: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub mutable_descriptor_type: Bool32,
}

impl Default for PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT,
            next: ptr::null_mut(),
            mutable_descriptor_type: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceNestedCommandBufferFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceNestedCommandBufferFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub nested_command_buffer: Bool32,
    pub nested_command_buffer_rendering: Bool32,
    pub nested_command_buffer_simultaneous_use: Bool32,
}

impl Default for PhysicalDeviceNestedCommandBufferFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT,
            next: ptr::null_mut(),
            nested_command_buffer: Bool32::default(),
            nested_command_buffer_rendering: Bool32::default(),
            nested_command_buffer_simultaneous_use: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceNestedCommandBufferPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceNestedCommandBufferPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_command_buffer_nesting_level: u32,
}

impl Default for PhysicalDeviceNestedCommandBufferPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT,
            next: ptr::null_mut(),
            max_command_buffer_nesting_level: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub non_seamless_cube_map: Bool32,
}

impl Default for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT,
            next: ptr::null_mut(),
            non_seamless_cube_map: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceOpacityMicromapFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceOpacityMicromapFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub micromap: Bool32,
    pub micromap_capture_replay: Bool32,
    pub micromap_host_commands: Bool32,
}

impl Default for PhysicalDeviceOpacityMicromapFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT,
            next: ptr::null_mut(),
            micromap: Bool32::default(),
            micromap_capture_replay: Bool32::default(),
            micromap_host_commands: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceOpacityMicromapPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceOpacityMicromapPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_opacity2_state_subdivision_level: u32,
    pub max_opacity4_state_subdivision_level: u32,
}

impl Default for PhysicalDeviceOpacityMicromapPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT,
            next: ptr::null_mut(),
            max_opacity2_state_subdivision_level: u32::default(),
            max_opacity4_state_subdivision_level: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceOpticalFlowFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceOpticalFlowFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub optical_flow: Bool32,
}

impl Default for PhysicalDeviceOpticalFlowFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV,
            next: ptr::null_mut(),
            optical_flow: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceOpticalFlowPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceOpticalFlowPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV,
    pub supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV,
    pub hint_supported: Bool32,
    pub cost_supported: Bool32,
    pub bidirectional_flow_supported: Bool32,
    pub global_flow_supported: Bool32,
    pub min_width: u32,
    pub min_height: u32,
    pub max_width: u32,
    pub max_height: u32,
    pub max_num_regions_of_interest: u32,
}

impl Default for PhysicalDeviceOpticalFlowPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV,
            next: ptr::null_mut(),
            supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV::default(),
            supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV::default(),
            hint_supported: Bool32::default(),
            cost_supported: Bool32::default(),
            bidirectional_flow_supported: Bool32::default(),
            global_flow_supported: Bool32::default(),
            min_width: u32::default(),
            min_height: u32::default(),
            max_width: u32::default(),
            max_height: u32::default(),
            max_num_regions_of_interest: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePCIBusInfoPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePCIBusInfoPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pci_domain: u32,
    pub pci_bus: u32,
    pub pci_device: u32,
    pub pci_function: u32,
}

impl Default for PhysicalDevicePCIBusInfoPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT,
            next: ptr::null_mut(),
            pci_domain: u32::default(),
            pci_bus: u32::default(),
            pci_device: u32::default(),
            pci_function: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pageable_device_local_memory: Bool32,
}

impl Default for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT,
            next: ptr::null_mut(),
            pageable_device_local_memory: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePartitionedAccelerationStructureFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub partitioned_acceleration_structure: Bool32,
}

impl Default for PhysicalDevicePartitionedAccelerationStructureFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV,
            next: ptr::null_mut(),
            partitioned_acceleration_structure: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePartitionedAccelerationStructurePropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_partition_count: u32,
}

impl Default for PhysicalDevicePartitionedAccelerationStructurePropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV,
            next: ptr::null_mut(),
            max_partition_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePerStageDescriptorSetFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePerStageDescriptorSetFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub per_stage_descriptor_set: Bool32,
    pub dynamic_pipeline_layout: Bool32,
}

impl Default for PhysicalDevicePerStageDescriptorSetFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV,
            next: ptr::null_mut(),
            per_stage_descriptor_set: Bool32::default(),
            dynamic_pipeline_layout: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePerformanceQueryFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePerformanceQueryFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub performance_counter_query_pools: Bool32,
    pub performance_counter_multiple_query_pools: Bool32,
}

impl Default for PhysicalDevicePerformanceQueryFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR,
            next: ptr::null_mut(),
            performance_counter_query_pools: Bool32::default(),
            performance_counter_multiple_query_pools: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePerformanceQueryPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePerformanceQueryPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub allow_command_buffer_query_copies: Bool32,
}

impl Default for PhysicalDevicePerformanceQueryPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR,
            next: ptr::null_mut(),
            allow_command_buffer_query_copies: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineBinaryFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePipelineBinaryFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pipeline_binaries: Bool32,
}

impl Default for PhysicalDevicePipelineBinaryFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR,
            next: ptr::null_mut(),
            pipeline_binaries: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineBinaryPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePipelineBinaryPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pipeline_binary_internal_cache: Bool32,
    pub pipeline_binary_internal_cache_control: Bool32,
    pub pipeline_binary_prefers_internal_cache: Bool32,
    pub pipeline_binary_precompiled_internal_cache: Bool32,
    pub pipeline_binary_compressed_data: Bool32,
}

impl Default for PhysicalDevicePipelineBinaryPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR,
            next: ptr::null_mut(),
            pipeline_binary_internal_cache: Bool32::default(),
            pipeline_binary_internal_cache_control: Bool32::default(),
            pipeline_binary_prefers_internal_cache: Bool32::default(),
            pipeline_binary_precompiled_internal_cache: Bool32::default(),
            pipeline_binary_compressed_data: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineCreationCacheControlFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePipelineCreationCacheControlFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pipeline_creation_cache_control: Bool32,
}

impl Default for PhysicalDevicePipelineCreationCacheControlFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES,
            next: ptr::null_mut(),
            pipeline_creation_cache_control: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pipeline_executable_info: Bool32,
}

impl Default for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR,
            next: ptr::null_mut(),
            pipeline_executable_info: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pipeline_library_group_handles: Bool32,
}

impl Default for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT,
            next: ptr::null_mut(),
            pipeline_library_group_handles: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineOpacityMicromapFeaturesARM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePipelineOpacityMicromapFeaturesARM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pipeline_opacity_micromap: Bool32,
}

impl Default for PhysicalDevicePipelineOpacityMicromapFeaturesARM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM,
            next: ptr::null_mut(),
            pipeline_opacity_micromap: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePipelinePropertiesFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePipelinePropertiesFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pipeline_properties_identifier: Bool32,
}

impl Default for PhysicalDevicePipelinePropertiesFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT,
            next: ptr::null_mut(),
            pipeline_properties_identifier: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineProtectedAccessFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePipelineProtectedAccessFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pipeline_protected_access: Bool32,
}

impl Default for PhysicalDevicePipelineProtectedAccessFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES,
            next: ptr::null_mut(),
            pipeline_protected_access: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineRobustnessFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePipelineRobustnessFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pipeline_robustness: Bool32,
}

impl Default for PhysicalDevicePipelineRobustnessFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES,
            next: ptr::null_mut(),
            pipeline_robustness: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineRobustnessProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePipelineRobustnessProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub default_robustness_storage_buffers: PipelineRobustnessBufferBehavior,
    pub default_robustness_uniform_buffers: PipelineRobustnessBufferBehavior,
    pub default_robustness_vertex_inputs: PipelineRobustnessBufferBehavior,
    pub default_robustness_images: PipelineRobustnessImageBehavior,
}

impl Default for PhysicalDevicePipelineRobustnessProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES,
            next: ptr::null_mut(),
            default_robustness_storage_buffers: PipelineRobustnessBufferBehavior::default(),
            default_robustness_uniform_buffers: PipelineRobustnessBufferBehavior::default(),
            default_robustness_vertex_inputs: PipelineRobustnessBufferBehavior::default(),
            default_robustness_images: PipelineRobustnessImageBehavior::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePointClippingProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePointClippingProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub point_clipping_behavior: PointClippingBehavior,
}

impl Default for PhysicalDevicePointClippingProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
            next: ptr::null_mut(),
            point_clipping_behavior: PointClippingBehavior::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePortabilitySubsetFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub constant_alpha_color_blend_factors: Bool32,
    pub events: Bool32,
    pub image_view_format_reinterpretation: Bool32,
    pub image_view_format_swizzle: Bool32,
    pub image_view_2d_on_3d_image: Bool32,
    pub multisample_array_image: Bool32,
    pub mutable_comparison_samplers: Bool32,
    pub point_polygons: Bool32,
    pub sampler_mip_lod_bias: Bool32,
    pub separate_stencil_mask_ref: Bool32,
    pub shader_sample_rate_interpolation_functions: Bool32,
    pub tessellation_isolines: Bool32,
    pub tessellation_point_mode: Bool32,
    pub triangle_fans: Bool32,
    pub vertex_attribute_access_beyond_stride: Bool32,
}

impl Default for PhysicalDevicePortabilitySubsetFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR,
            next: ptr::null_mut(),
            constant_alpha_color_blend_factors: Bool32::default(),
            events: Bool32::default(),
            image_view_format_reinterpretation: Bool32::default(),
            image_view_format_swizzle: Bool32::default(),
            image_view_2d_on_3d_image: Bool32::default(),
            multisample_array_image: Bool32::default(),
            mutable_comparison_samplers: Bool32::default(),
            point_polygons: Bool32::default(),
            sampler_mip_lod_bias: Bool32::default(),
            separate_stencil_mask_ref: Bool32::default(),
            shader_sample_rate_interpolation_functions: Bool32::default(),
            tessellation_isolines: Bool32::default(),
            tessellation_point_mode: Bool32::default(),
            triangle_fans: Bool32::default(),
            vertex_attribute_access_beyond_stride: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePortabilitySubsetPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePortabilitySubsetPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub min_vertex_input_binding_stride_alignment: u32,
}

impl Default for PhysicalDevicePortabilitySubsetPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR,
            next: ptr::null_mut(),
            min_vertex_input_binding_stride_alignment: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePresentBarrierFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePresentBarrierFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub present_barrier: Bool32,
}

impl Default for PhysicalDevicePresentBarrierFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV,
            next: ptr::null_mut(),
            present_barrier: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePresentIdFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePresentIdFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub present_id: Bool32,
}

impl Default for PhysicalDevicePresentIdFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR,
            next: ptr::null_mut(),
            present_id: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePresentMeteringFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePresentMeteringFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub present_metering: Bool32,
}

impl Default for PhysicalDevicePresentMeteringFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV,
            next: ptr::null_mut(),
            present_metering: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub present_mode_fifo_latest_ready: Bool32,
}

impl Default for PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT,
            next: ptr::null_mut(),
            present_mode_fifo_latest_ready: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePresentWaitFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePresentWaitFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub present_wait: Bool32,
}

impl Default for PhysicalDevicePresentWaitFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR,
            next: ptr::null_mut(),
            present_wait: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub primitive_topology_list_restart: Bool32,
    pub primitive_topology_patch_list_restart: Bool32,
}

impl Default for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT,
            next: ptr::null_mut(),
            primitive_topology_list_restart: Bool32::default(),
            primitive_topology_patch_list_restart: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub primitives_generated_query: Bool32,
    pub primitives_generated_query_with_rasterizer_discard: Bool32,
    pub primitives_generated_query_with_non_zero_streams: Bool32,
}

impl Default for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT,
            next: ptr::null_mut(),
            primitives_generated_query: Bool32::default(),
            primitives_generated_query_with_rasterizer_discard: Bool32::default(),
            primitives_generated_query_with_non_zero_streams: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePrivateDataFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePrivateDataFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub private_data: Bool32,
}

impl Default for PhysicalDevicePrivateDataFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES,
            next: ptr::null_mut(),
            private_data: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq)]
pub struct PhysicalDeviceProperties {
    pub api_version: u32,
    pub driver_version: u32,
    pub vendor_id: u32,
    pub device_id: u32,
    pub device_type: PhysicalDeviceType,
    pub device_name: StringArray<MAX_PHYSICAL_DEVICE_NAME_SIZE>,
    pub pipeline_cache_uuid: ByteArray<UUID_SIZE>,
    pub limits: PhysicalDeviceLimits,
    pub sparse_properties: PhysicalDeviceSparseProperties,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceProperties2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct PhysicalDeviceProperties2 {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub properties: PhysicalDeviceProperties,
}

impl Default for PhysicalDeviceProperties2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PROPERTIES_2,
            next: ptr::null_mut(),
            properties: PhysicalDeviceProperties::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceProtectedMemoryFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceProtectedMemoryFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub protected_memory: Bool32,
}

impl Default for PhysicalDeviceProtectedMemoryFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES,
            next: ptr::null_mut(),
            protected_memory: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceProtectedMemoryProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceProtectedMemoryProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub protected_no_fault: Bool32,
}

impl Default for PhysicalDeviceProtectedMemoryProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES,
            next: ptr::null_mut(),
            protected_no_fault: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceProvokingVertexFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceProvokingVertexFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub provoking_vertex_last: Bool32,
    pub transform_feedback_preserves_provoking_vertex: Bool32,
}

impl Default for PhysicalDeviceProvokingVertexFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT,
            next: ptr::null_mut(),
            provoking_vertex_last: Bool32::default(),
            transform_feedback_preserves_provoking_vertex: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceProvokingVertexPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceProvokingVertexPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub provoking_vertex_mode_per_pipeline: Bool32,
    pub transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32,
}

impl Default for PhysicalDeviceProvokingVertexPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT,
            next: ptr::null_mut(),
            provoking_vertex_mode_per_pipeline: Bool32::default(),
            transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePushDescriptorProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDevicePushDescriptorProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_push_descriptors: u32,
}

impl Default for PhysicalDevicePushDescriptorProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES,
            next: ptr::null_mut(),
            max_push_descriptors: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub format_rgba10x6_without_y_cb_cr_sampler: Bool32,
}

impl Default for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT,
            next: ptr::null_mut(),
            format_rgba10x6_without_y_cb_cr_sampler: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub rasterization_order_color_attachment_access: Bool32,
    pub rasterization_order_depth_attachment_access: Bool32,
    pub rasterization_order_stencil_attachment_access: Bool32,
}

impl Default for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type:
                StructureType::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT,
            next: ptr::null_mut(),
            rasterization_order_color_attachment_access: Bool32::default(),
            rasterization_order_depth_attachment_access: Bool32::default(),
            rasterization_order_stencil_attachment_access: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRawAccessChainsFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRawAccessChainsFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_raw_access_chains: Bool32,
}

impl Default for PhysicalDeviceRawAccessChainsFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV,
            next: ptr::null_mut(),
            shader_raw_access_chains: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRayQueryFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRayQueryFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub ray_query: Bool32,
}

impl Default for PhysicalDeviceRayQueryFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR,
            next: ptr::null_mut(),
            ray_query: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub ray_tracing_invocation_reorder: Bool32,
}

impl Default for PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV,
            next: ptr::null_mut(),
            ray_tracing_invocation_reorder: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub ray_tracing_invocation_reorder_reordering_hint: RayTracingInvocationReorderModeNV,
}

impl Default for PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV,
            next: ptr::null_mut(),
            ray_tracing_invocation_reorder_reordering_hint:
                RayTracingInvocationReorderModeNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub spheres: Bool32,
    pub linear_swept_spheres: Bool32,
}

impl Default for PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV,
            next: ptr::null_mut(),
            spheres: Bool32::default(),
            linear_swept_spheres: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub ray_tracing_maintenance1: Bool32,
    pub ray_tracing_pipeline_trace_rays_indirect2: Bool32,
}

impl Default for PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR,
            next: ptr::null_mut(),
            ray_tracing_maintenance1: Bool32::default(),
            ray_tracing_pipeline_trace_rays_indirect2: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub ray_tracing_motion_blur: Bool32,
    pub ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32,
}

impl Default for PhysicalDeviceRayTracingMotionBlurFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV,
            next: ptr::null_mut(),
            ray_tracing_motion_blur: Bool32::default(),
            ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRayTracingPipelineFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub ray_tracing_pipeline: Bool32,
    pub ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32,
    pub ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32,
    pub ray_tracing_pipeline_trace_rays_indirect: Bool32,
    pub ray_traversal_primitive_culling: Bool32,
}

impl Default for PhysicalDeviceRayTracingPipelineFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR,
            next: ptr::null_mut(),
            ray_tracing_pipeline: Bool32::default(),
            ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32::default(),
            ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32::default(),
            ray_tracing_pipeline_trace_rays_indirect: Bool32::default(),
            ray_traversal_primitive_culling: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRayTracingPipelinePropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_group_handle_size: u32,
    pub max_ray_recursion_depth: u32,
    pub max_shader_group_stride: u32,
    pub shader_group_base_alignment: u32,
    pub shader_group_handle_capture_replay_size: u32,
    pub max_ray_dispatch_invocation_count: u32,
    pub shader_group_handle_alignment: u32,
    pub max_ray_hit_attribute_size: u32,
}

impl Default for PhysicalDeviceRayTracingPipelinePropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR,
            next: ptr::null_mut(),
            shader_group_handle_size: u32::default(),
            max_ray_recursion_depth: u32::default(),
            max_shader_group_stride: u32::default(),
            shader_group_base_alignment: u32::default(),
            shader_group_handle_capture_replay_size: u32::default(),
            max_ray_dispatch_invocation_count: u32::default(),
            shader_group_handle_alignment: u32::default(),
            max_ray_hit_attribute_size: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub ray_tracing_position_fetch: Bool32,
}

impl Default for PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR,
            next: ptr::null_mut(),
            ray_tracing_position_fetch: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRayTracingPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_group_handle_size: u32,
    pub max_recursion_depth: u32,
    pub max_shader_group_stride: u32,
    pub shader_group_base_alignment: u32,
    pub max_geometry_count: u64,
    pub max_instance_count: u64,
    pub max_triangle_count: u64,
    pub max_descriptor_set_acceleration_structures: u32,
}

impl Default for PhysicalDeviceRayTracingPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV,
            next: ptr::null_mut(),
            shader_group_handle_size: u32::default(),
            max_recursion_depth: u32::default(),
            max_shader_group_stride: u32::default(),
            shader_group_base_alignment: u32::default(),
            max_geometry_count: u64::default(),
            max_instance_count: u64::default(),
            max_triangle_count: u64::default(),
            max_descriptor_set_acceleration_structures: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingValidationFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRayTracingValidationFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub ray_tracing_validation: Bool32,
}

impl Default for PhysicalDeviceRayTracingValidationFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV,
            next: ptr::null_mut(),
            ray_tracing_validation: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub relaxed_line_rasterization: Bool32,
}

impl Default for PhysicalDeviceRelaxedLineRasterizationFeaturesIMG {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG,
            next: ptr::null_mut(),
            relaxed_line_rasterization: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRenderPassStripedFeaturesARM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRenderPassStripedFeaturesARM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub render_pass_striped: Bool32,
}

impl Default for PhysicalDeviceRenderPassStripedFeaturesARM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM,
            next: ptr::null_mut(),
            render_pass_striped: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRenderPassStripedPropertiesARM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRenderPassStripedPropertiesARM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub render_pass_stripe_granularity: Extent2D,
    pub max_render_pass_stripes: u32,
}

impl Default for PhysicalDeviceRenderPassStripedPropertiesARM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM,
            next: ptr::null_mut(),
            render_pass_stripe_granularity: Extent2D::default(),
            max_render_pass_stripes: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub representative_fragment_test: Bool32,
}

impl Default for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV,
            next: ptr::null_mut(),
            representative_fragment_test: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRobustness2FeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRobustness2FeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub robust_buffer_access2: Bool32,
    pub robust_image_access2: Bool32,
    pub null_descriptor: Bool32,
}

impl Default for PhysicalDeviceRobustness2FeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT,
            next: ptr::null_mut(),
            robust_buffer_access2: Bool32::default(),
            robust_image_access2: Bool32::default(),
            null_descriptor: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRobustness2PropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceRobustness2PropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub robust_storage_buffer_access_size_alignment: DeviceSize,
    pub robust_uniform_buffer_access_size_alignment: DeviceSize,
}

impl Default for PhysicalDeviceRobustness2PropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT,
            next: ptr::null_mut(),
            robust_storage_buffer_access_size_alignment: DeviceSize::default(),
            robust_uniform_buffer_access_size_alignment: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct PhysicalDeviceSampleLocationsPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub sample_location_sample_counts: SampleCountFlags,
    pub max_sample_location_grid_size: Extent2D,
    pub sample_location_coordinate_range: [f32; 2],
    pub sample_location_sub_pixel_bits: u32,
    pub variable_sample_locations: Bool32,
}

impl Default for PhysicalDeviceSampleLocationsPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT,
            next: ptr::null_mut(),
            sample_location_sample_counts: SampleCountFlags::default(),
            max_sample_location_grid_size: Extent2D::default(),
            sample_location_coordinate_range: [f32::default(); 2],
            sample_location_sub_pixel_bits: u32::default(),
            variable_sample_locations: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSamplerFilterMinmaxProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceSamplerFilterMinmaxProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub filter_minmax_single_component_formats: Bool32,
    pub filter_minmax_image_component_mapping: Bool32,
}

impl Default for PhysicalDeviceSamplerFilterMinmaxProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES,
            next: ptr::null_mut(),
            filter_minmax_single_component_formats: Bool32::default(),
            filter_minmax_image_component_mapping: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSamplerYcbcrConversionFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceSamplerYcbcrConversionFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub sampler_ycbcr_conversion: Bool32,
}

impl Default for PhysicalDeviceSamplerYcbcrConversionFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
            next: ptr::null_mut(),
            sampler_ycbcr_conversion: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceScalarBlockLayoutFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceScalarBlockLayoutFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub scalar_block_layout: Bool32,
}

impl Default for PhysicalDeviceScalarBlockLayoutFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES,
            next: ptr::null_mut(),
            scalar_block_layout: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSchedulingControlsFeaturesARM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceSchedulingControlsFeaturesARM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub scheduling_controls: Bool32,
}

impl Default for PhysicalDeviceSchedulingControlsFeaturesARM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM,
            next: ptr::null_mut(),
            scheduling_controls: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSchedulingControlsPropertiesARM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceSchedulingControlsPropertiesARM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub scheduling_controls_flags: PhysicalDeviceSchedulingControlsFlagsARM,
}

impl Default for PhysicalDeviceSchedulingControlsPropertiesARM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM,
            next: ptr::null_mut(),
            scheduling_controls_flags: PhysicalDeviceSchedulingControlsFlagsARM::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub separate_depth_stencil_layouts: Bool32,
}

impl Default for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES,
            next: ptr::null_mut(),
            separate_depth_stencil_layouts: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_float16_vector_atomics: Bool32,
}

impl Default for PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV,
            next: ptr::null_mut(),
            shader_float16_vector_atomics: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_buffer_float16_atomics: Bool32,
    pub shader_buffer_float16_atomic_add: Bool32,
    pub shader_buffer_float16_atomic_min_max: Bool32,
    pub shader_buffer_float32_atomic_min_max: Bool32,
    pub shader_buffer_float64_atomic_min_max: Bool32,
    pub shader_shared_float16_atomics: Bool32,
    pub shader_shared_float16_atomic_add: Bool32,
    pub shader_shared_float16_atomic_min_max: Bool32,
    pub shader_shared_float32_atomic_min_max: Bool32,
    pub shader_shared_float64_atomic_min_max: Bool32,
    pub shader_image_float32_atomic_min_max: Bool32,
    pub sparse_image_float32_atomic_min_max: Bool32,
}

impl Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT,
            next: ptr::null_mut(),
            shader_buffer_float16_atomics: Bool32::default(),
            shader_buffer_float16_atomic_add: Bool32::default(),
            shader_buffer_float16_atomic_min_max: Bool32::default(),
            shader_buffer_float32_atomic_min_max: Bool32::default(),
            shader_buffer_float64_atomic_min_max: Bool32::default(),
            shader_shared_float16_atomics: Bool32::default(),
            shader_shared_float16_atomic_add: Bool32::default(),
            shader_shared_float16_atomic_min_max: Bool32::default(),
            shader_shared_float32_atomic_min_max: Bool32::default(),
            shader_shared_float64_atomic_min_max: Bool32::default(),
            shader_image_float32_atomic_min_max: Bool32::default(),
            sparse_image_float32_atomic_min_max: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_buffer_float32_atomics: Bool32,
    pub shader_buffer_float32_atomic_add: Bool32,
    pub shader_buffer_float64_atomics: Bool32,
    pub shader_buffer_float64_atomic_add: Bool32,
    pub shader_shared_float32_atomics: Bool32,
    pub shader_shared_float32_atomic_add: Bool32,
    pub shader_shared_float64_atomics: Bool32,
    pub shader_shared_float64_atomic_add: Bool32,
    pub shader_image_float32_atomics: Bool32,
    pub shader_image_float32_atomic_add: Bool32,
    pub sparse_image_float32_atomics: Bool32,
    pub sparse_image_float32_atomic_add: Bool32,
}

impl Default for PhysicalDeviceShaderAtomicFloatFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT,
            next: ptr::null_mut(),
            shader_buffer_float32_atomics: Bool32::default(),
            shader_buffer_float32_atomic_add: Bool32::default(),
            shader_buffer_float64_atomics: Bool32::default(),
            shader_buffer_float64_atomic_add: Bool32::default(),
            shader_shared_float32_atomics: Bool32::default(),
            shader_shared_float32_atomic_add: Bool32::default(),
            shader_shared_float64_atomics: Bool32::default(),
            shader_shared_float64_atomic_add: Bool32::default(),
            shader_image_float32_atomics: Bool32::default(),
            shader_image_float32_atomic_add: Bool32::default(),
            sparse_image_float32_atomics: Bool32::default(),
            sparse_image_float32_atomic_add: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAtomicInt64Features.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderAtomicInt64Features {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_buffer_int64_atomics: Bool32,
    pub shader_shared_int64_atomics: Bool32,
}

impl Default for PhysicalDeviceShaderAtomicInt64Features {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
            next: ptr::null_mut(),
            shader_buffer_int64_atomics: Bool32::default(),
            shader_shared_int64_atomics: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderClockFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderClockFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_subgroup_clock: Bool32,
    pub shader_device_clock: Bool32,
}

impl Default for PhysicalDeviceShaderClockFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR,
            next: ptr::null_mut(),
            shader_subgroup_clock: Bool32::default(),
            shader_device_clock: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_core_builtins: Bool32,
}

impl Default for PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM,
            next: ptr::null_mut(),
            shader_core_builtins: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_core_mask: u64,
    pub shader_core_count: u32,
    pub shader_warps_per_core: u32,
}

impl Default for PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM,
            next: ptr::null_mut(),
            shader_core_mask: u64::default(),
            shader_core_count: u32::default(),
            shader_warps_per_core: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderCoreProperties2AMD.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderCoreProperties2AMD {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_core_features: ShaderCorePropertiesFlagsAMD,
    pub active_compute_unit_count: u32,
}

impl Default for PhysicalDeviceShaderCoreProperties2AMD {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD,
            next: ptr::null_mut(),
            shader_core_features: ShaderCorePropertiesFlagsAMD::default(),
            active_compute_unit_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderCorePropertiesAMD {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_engine_count: u32,
    pub shader_arrays_per_engine_count: u32,
    pub compute_units_per_shader_array: u32,
    pub simd_per_compute_unit: u32,
    pub wavefronts_per_simd: u32,
    pub wavefront_size: u32,
    pub sgprs_per_simd: u32,
    pub min_sgpr_allocation: u32,
    pub max_sgpr_allocation: u32,
    pub sgpr_allocation_granularity: u32,
    pub vgprs_per_simd: u32,
    pub min_vgpr_allocation: u32,
    pub max_vgpr_allocation: u32,
    pub vgpr_allocation_granularity: u32,
}

impl Default for PhysicalDeviceShaderCorePropertiesAMD {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD,
            next: ptr::null_mut(),
            shader_engine_count: u32::default(),
            shader_arrays_per_engine_count: u32::default(),
            compute_units_per_shader_array: u32::default(),
            simd_per_compute_unit: u32::default(),
            wavefronts_per_simd: u32::default(),
            wavefront_size: u32::default(),
            sgprs_per_simd: u32::default(),
            min_sgpr_allocation: u32::default(),
            max_sgpr_allocation: u32::default(),
            sgpr_allocation_granularity: u32::default(),
            vgprs_per_simd: u32::default(),
            min_vgpr_allocation: u32::default(),
            max_vgpr_allocation: u32::default(),
            vgpr_allocation_granularity: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderCorePropertiesARM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderCorePropertiesARM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pixel_rate: u32,
    pub texel_rate: u32,
    pub fma_rate: u32,
}

impl Default for PhysicalDeviceShaderCorePropertiesARM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM,
            next: ptr::null_mut(),
            pixel_rate: u32::default(),
            texel_rate: u32::default(),
            fma_rate: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_demote_to_helper_invocation: Bool32,
}

impl Default for PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES,
            next: ptr::null_mut(),
            shader_demote_to_helper_invocation: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderDrawParametersFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderDrawParametersFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_draw_parameters: Bool32,
}

impl Default for PhysicalDeviceShaderDrawParametersFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
            next: ptr::null_mut(),
            shader_draw_parameters: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_early_and_late_fragment_tests: Bool32,
}

impl Default for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
    #[inline]
    fn default() -> Self {
        Self {
            s_type:
                StructureType::PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD,
            next: ptr::null_mut(),
            shader_early_and_late_fragment_tests: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderEnqueueFeaturesAMDX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderEnqueueFeaturesAMDX {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_enqueue: Bool32,
    pub shader_mesh_enqueue: Bool32,
}

impl Default for PhysicalDeviceShaderEnqueueFeaturesAMDX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX,
            next: ptr::null_mut(),
            shader_enqueue: Bool32::default(),
            shader_mesh_enqueue: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderEnqueuePropertiesAMDX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderEnqueuePropertiesAMDX {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_execution_graph_depth: u32,
    pub max_execution_graph_shader_output_nodes: u32,
    pub max_execution_graph_shader_payload_size: u32,
    pub max_execution_graph_shader_payload_count: u32,
    pub execution_graph_dispatch_address_alignment: u32,
    pub max_execution_graph_workgroup_count: [u32; 3],
    pub max_execution_graph_workgroups: u32,
}

impl Default for PhysicalDeviceShaderEnqueuePropertiesAMDX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX,
            next: ptr::null_mut(),
            max_execution_graph_depth: u32::default(),
            max_execution_graph_shader_output_nodes: u32::default(),
            max_execution_graph_shader_payload_size: u32::default(),
            max_execution_graph_shader_payload_count: u32::default(),
            execution_graph_dispatch_address_alignment: u32::default(),
            max_execution_graph_workgroup_count: [u32::default(); 3],
            max_execution_graph_workgroups: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderExpectAssumeFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderExpectAssumeFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_expect_assume: Bool32,
}

impl Default for PhysicalDeviceShaderExpectAssumeFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES,
            next: ptr::null_mut(),
            shader_expect_assume: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderFloat16Int8Features.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderFloat16Int8Features {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_float16: Bool32,
    pub shader_int8: Bool32,
}

impl Default for PhysicalDeviceShaderFloat16Int8Features {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
            next: ptr::null_mut(),
            shader_float16: Bool32::default(),
            shader_int8: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderFloatControls2Features.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderFloatControls2Features {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_float_controls2: Bool32,
}

impl Default for PhysicalDeviceShaderFloatControls2Features {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES,
            next: ptr::null_mut(),
            shader_float_controls2: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_image_int64_atomics: Bool32,
    pub sparse_image_int64_atomics: Bool32,
}

impl Default for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT,
            next: ptr::null_mut(),
            shader_image_int64_atomics: Bool32::default(),
            sparse_image_int64_atomics: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderImageFootprintFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderImageFootprintFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub image_footprint: Bool32,
}

impl Default for PhysicalDeviceShaderImageFootprintFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV,
            next: ptr::null_mut(),
            image_footprint: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderIntegerDotProductFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderIntegerDotProductFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_integer_dot_product: Bool32,
}

impl Default for PhysicalDeviceShaderIntegerDotProductFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES,
            next: ptr::null_mut(),
            shader_integer_dot_product: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderIntegerDotProductProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderIntegerDotProductProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub integer_dot_product_8bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_8bit_signed_accelerated: Bool32,
    pub integer_dot_product_8bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product4x_8bit_packed_unsigned_accelerated: Bool32,
    pub integer_dot_product4x_8bit_packed_signed_accelerated: Bool32,
    pub integer_dot_product4x_8bit_packed_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_16bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_16bit_signed_accelerated: Bool32,
    pub integer_dot_product_16bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_32bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_32bit_signed_accelerated: Bool32,
    pub integer_dot_product_32bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_64bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_64bit_signed_accelerated: Bool32,
    pub integer_dot_product_64bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_8bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_8bit_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_8bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating4x_8bit_packed_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating4x_8bit_packed_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating4x_8bit_packed_mixed_signedness_accelerated:
        Bool32,
    pub integer_dot_product_accumulating_saturating_16bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_16bit_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_16bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_32bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_32bit_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_32bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_64bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_64bit_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_64bit_mixed_signedness_accelerated: Bool32,
}

impl Default for PhysicalDeviceShaderIntegerDotProductProperties {
    #[inline]
    fn default() -> Self {
        Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, next: ptr::null_mut(), integer_dot_product_8bit_unsigned_accelerated: Bool32::default(), integer_dot_product_8bit_signed_accelerated: Bool32::default(), integer_dot_product_8bit_mixed_signedness_accelerated: Bool32::default(), integer_dot_product4x_8bit_packed_unsigned_accelerated: Bool32::default(), integer_dot_product4x_8bit_packed_signed_accelerated: Bool32::default(), integer_dot_product4x_8bit_packed_mixed_signedness_accelerated: Bool32::default(), integer_dot_product_16bit_unsigned_accelerated: Bool32::default(), integer_dot_product_16bit_signed_accelerated: Bool32::default(), integer_dot_product_16bit_mixed_signedness_accelerated: Bool32::default(), integer_dot_product_32bit_unsigned_accelerated: Bool32::default(), integer_dot_product_32bit_signed_accelerated: Bool32::default(), integer_dot_product_32bit_mixed_signedness_accelerated: Bool32::default(), integer_dot_product_64bit_unsigned_accelerated: Bool32::default(), integer_dot_product_64bit_signed_accelerated: Bool32::default(), integer_dot_product_64bit_mixed_signedness_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_8bit_unsigned_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_8bit_signed_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_8bit_mixed_signedness_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating4x_8bit_packed_unsigned_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating4x_8bit_packed_signed_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating4x_8bit_packed_mixed_signedness_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_16bit_unsigned_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_16bit_signed_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_16bit_mixed_signedness_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_32bit_unsigned_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_32bit_signed_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_32bit_mixed_signedness_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_64bit_unsigned_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_64bit_signed_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_64bit_mixed_signedness_accelerated: Bool32::default() }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_integer_functions2: Bool32,
}

impl Default for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL,
            next: ptr::null_mut(),
            shader_integer_functions2: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_maximal_reconvergence: Bool32,
}

impl Default for PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR,
            next: ptr::null_mut(),
            shader_maximal_reconvergence: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_module_identifier: Bool32,
}

impl Default for PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT,
            next: ptr::null_mut(),
            shader_module_identifier: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_module_identifier_algorithm_uuid: ByteArray<UUID_SIZE>,
}

impl Default for PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT,
            next: ptr::null_mut(),
            shader_module_identifier_algorithm_uuid: ByteArray::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderObjectFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderObjectFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_object: Bool32,
}

impl Default for PhysicalDeviceShaderObjectFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT,
            next: ptr::null_mut(),
            shader_object: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderObjectPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderObjectPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_binary_uuid: ByteArray<UUID_SIZE>,
    pub shader_binary_version: u32,
}

impl Default for PhysicalDeviceShaderObjectPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT,
            next: ptr::null_mut(),
            shader_binary_uuid: ByteArray::default(),
            shader_binary_version: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderQuadControlFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderQuadControlFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_quad_control: Bool32,
}

impl Default for PhysicalDeviceShaderQuadControlFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR,
            next: ptr::null_mut(),
            shader_quad_control: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_relaxed_extended_instruction: Bool32,
}

impl Default for PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR,
            next: ptr::null_mut(),
            shader_relaxed_extended_instruction: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderReplicatedCompositesFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_replicated_composites: Bool32,
}

impl Default for PhysicalDeviceShaderReplicatedCompositesFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT,
            next: ptr::null_mut(),
            shader_replicated_composites: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_sm_builtins: Bool32,
}

impl Default for PhysicalDeviceShaderSMBuiltinsFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV,
            next: ptr::null_mut(),
            shader_sm_builtins: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_sm_count: u32,
    pub shader_warps_per_sm: u32,
}

impl Default for PhysicalDeviceShaderSMBuiltinsPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV,
            next: ptr::null_mut(),
            shader_sm_count: u32::default(),
            shader_warps_per_sm: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_subgroup_extended_types: Bool32,
}

impl Default for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
            next: ptr::null_mut(),
            shader_subgroup_extended_types: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSubgroupRotateFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderSubgroupRotateFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_subgroup_rotate: Bool32,
    pub shader_subgroup_rotate_clustered: Bool32,
}

impl Default for PhysicalDeviceShaderSubgroupRotateFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES,
            next: ptr::null_mut(),
            shader_subgroup_rotate: Bool32::default(),
            shader_subgroup_rotate_clustered: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_subgroup_uniform_control_flow: Bool32,
}

impl Default for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type:
                StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR,
            next: ptr::null_mut(),
            shader_subgroup_uniform_control_flow: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderTerminateInvocationFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderTerminateInvocationFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_terminate_invocation: Bool32,
}

impl Default for PhysicalDeviceShaderTerminateInvocationFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES,
            next: ptr::null_mut(),
            shader_terminate_invocation: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderTileImageFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderTileImageFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_tile_image_color_read_access: Bool32,
    pub shader_tile_image_depth_read_access: Bool32,
    pub shader_tile_image_stencil_read_access: Bool32,
}

impl Default for PhysicalDeviceShaderTileImageFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT,
            next: ptr::null_mut(),
            shader_tile_image_color_read_access: Bool32::default(),
            shader_tile_image_depth_read_access: Bool32::default(),
            shader_tile_image_stencil_read_access: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderTileImagePropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShaderTileImagePropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_tile_image_coherent_read_accelerated: Bool32,
    pub shader_tile_image_read_sample_from_pixel_rate_invocation: Bool32,
    pub shader_tile_image_read_from_helper_invocation: Bool32,
}

impl Default for PhysicalDeviceShaderTileImagePropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT,
            next: ptr::null_mut(),
            shader_tile_image_coherent_read_accelerated: Bool32::default(),
            shader_tile_image_read_sample_from_pixel_rate_invocation: Bool32::default(),
            shader_tile_image_read_from_helper_invocation: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShadingRateImageFeaturesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShadingRateImageFeaturesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shading_rate_image: Bool32,
    pub shading_rate_coarse_sample_order: Bool32,
}

impl Default for PhysicalDeviceShadingRateImageFeaturesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV,
            next: ptr::null_mut(),
            shading_rate_image: Bool32::default(),
            shading_rate_coarse_sample_order: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShadingRateImagePropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceShadingRateImagePropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shading_rate_texel_size: Extent2D,
    pub shading_rate_palette_size: u32,
    pub shading_rate_max_coarse_samples: u32,
}

impl Default for PhysicalDeviceShadingRateImagePropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV,
            next: ptr::null_mut(),
            shading_rate_texel_size: Extent2D::default(),
            shading_rate_palette_size: u32::default(),
            shading_rate_max_coarse_samples: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSparseImageFormatInfo2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceSparseImageFormatInfo2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub format: Format,
    pub type_: ImageType,
    pub samples: SampleCountFlags,
    pub usage: ImageUsageFlags,
    pub tiling: ImageTiling,
}

impl Default for PhysicalDeviceSparseImageFormatInfo2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
            next: ptr::null(),
            format: Format::default(),
            type_: ImageType::default(),
            samples: SampleCountFlags::default(),
            usage: ImageUsageFlags::default(),
            tiling: ImageTiling::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSparseProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceSparseProperties {
    pub residency_standard_2d_block_shape: Bool32,
    pub residency_standard_2d_multisample_block_shape: Bool32,
    pub residency_standard_3d_block_shape: Bool32,
    pub residency_aligned_mip_size: Bool32,
    pub residency_non_resident_strict: Bool32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSubgroupProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceSubgroupProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub subgroup_size: u32,
    pub supported_stages: ShaderStageFlags,
    pub supported_operations: SubgroupFeatureFlags,
    pub quad_operations_in_all_stages: Bool32,
}

impl Default for PhysicalDeviceSubgroupProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES,
            next: ptr::null_mut(),
            subgroup_size: u32::default(),
            supported_stages: ShaderStageFlags::default(),
            supported_operations: SubgroupFeatureFlags::default(),
            quad_operations_in_all_stages: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSubgroupSizeControlFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceSubgroupSizeControlFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub subgroup_size_control: Bool32,
    pub compute_full_subgroups: Bool32,
}

impl Default for PhysicalDeviceSubgroupSizeControlFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES,
            next: ptr::null_mut(),
            subgroup_size_control: Bool32::default(),
            compute_full_subgroups: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSubgroupSizeControlProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceSubgroupSizeControlProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub min_subgroup_size: u32,
    pub max_subgroup_size: u32,
    pub max_compute_workgroup_subgroups: u32,
    pub required_subgroup_size_stages: ShaderStageFlags,
}

impl Default for PhysicalDeviceSubgroupSizeControlProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES,
            next: ptr::null_mut(),
            min_subgroup_size: u32::default(),
            max_subgroup_size: u32::default(),
            max_compute_workgroup_subgroups: u32::default(),
            required_subgroup_size_stages: ShaderStageFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub subpass_merge_feedback: Bool32,
}

impl Default for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT,
            next: ptr::null_mut(),
            subpass_merge_feedback: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEI {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub subpass_shading: Bool32,
}

impl Default for PhysicalDeviceSubpassShadingFeaturesHUAWEI {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI,
            next: ptr::null_mut(),
            subpass_shading: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSubpassShadingPropertiesHUAWEI.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEI {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_subpass_shading_workgroup_size_aspect_ratio: u32,
}

impl Default for PhysicalDeviceSubpassShadingPropertiesHUAWEI {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI,
            next: ptr::null_mut(),
            max_subpass_shading_workgroup_size_aspect_ratio: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSurfaceInfo2KHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceSurfaceInfo2KHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub surface: SurfaceKHR,
}

impl Default for PhysicalDeviceSurfaceInfo2KHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
            next: ptr::null(),
            surface: SurfaceKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceSwapchainMaintenance1FeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub swapchain_maintenance1: Bool32,
}

impl Default for PhysicalDeviceSwapchainMaintenance1FeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT,
            next: ptr::null_mut(),
            swapchain_maintenance1: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSynchronization2Features.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceSynchronization2Features {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub synchronization2: Bool32,
}

impl Default for PhysicalDeviceSynchronization2Features {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES,
            next: ptr::null_mut(),
            synchronization2: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub texel_buffer_alignment: Bool32,
}

impl Default for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT,
            next: ptr::null_mut(),
            texel_buffer_alignment: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceTexelBufferAlignmentProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceTexelBufferAlignmentProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub storage_texel_buffer_offset_alignment_bytes: DeviceSize,
    pub storage_texel_buffer_offset_single_texel_alignment: Bool32,
    pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
    pub uniform_texel_buffer_offset_single_texel_alignment: Bool32,
}

impl Default for PhysicalDeviceTexelBufferAlignmentProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES,
            next: ptr::null_mut(),
            storage_texel_buffer_offset_alignment_bytes: DeviceSize::default(),
            storage_texel_buffer_offset_single_texel_alignment: Bool32::default(),
            uniform_texel_buffer_offset_alignment_bytes: DeviceSize::default(),
            uniform_texel_buffer_offset_single_texel_alignment: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceTextureCompressionASTCHDRFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceTextureCompressionASTCHDRFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub texture_compression_astc_hdr: Bool32,
}

impl Default for PhysicalDeviceTextureCompressionASTCHDRFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES,
            next: ptr::null_mut(),
            texture_compression_astc_hdr: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceTilePropertiesFeaturesQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceTilePropertiesFeaturesQCOM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub tile_properties: Bool32,
}

impl Default for PhysicalDeviceTilePropertiesFeaturesQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM,
            next: ptr::null_mut(),
            tile_properties: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceTimelineSemaphoreFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceTimelineSemaphoreFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub timeline_semaphore: Bool32,
}

impl Default for PhysicalDeviceTimelineSemaphoreFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES,
            next: ptr::null_mut(),
            timeline_semaphore: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceTimelineSemaphoreProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceTimelineSemaphoreProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_timeline_semaphore_value_difference: u64,
}

impl Default for PhysicalDeviceTimelineSemaphoreProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES,
            next: ptr::null_mut(),
            max_timeline_semaphore_value_difference: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceToolProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceToolProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub name: StringArray<MAX_EXTENSION_NAME_SIZE>,
    pub version: StringArray<MAX_EXTENSION_NAME_SIZE>,
    pub purposes: ToolPurposeFlags,
    pub description: StringArray<MAX_DESCRIPTION_SIZE>,
    pub layer: StringArray<MAX_EXTENSION_NAME_SIZE>,
}

impl Default for PhysicalDeviceToolProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_TOOL_PROPERTIES,
            next: ptr::null_mut(),
            name: StringArray::default(),
            version: StringArray::default(),
            purposes: ToolPurposeFlags::default(),
            description: StringArray::default(),
            layer: StringArray::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceTransformFeedbackFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceTransformFeedbackFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub transform_feedback: Bool32,
    pub geometry_streams: Bool32,
}

impl Default for PhysicalDeviceTransformFeedbackFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT,
            next: ptr::null_mut(),
            transform_feedback: Bool32::default(),
            geometry_streams: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceTransformFeedbackPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_transform_feedback_streams: u32,
    pub max_transform_feedback_buffers: u32,
    pub max_transform_feedback_buffer_size: DeviceSize,
    pub max_transform_feedback_stream_data_size: u32,
    pub max_transform_feedback_buffer_data_size: u32,
    pub max_transform_feedback_buffer_data_stride: u32,
    pub transform_feedback_queries: Bool32,
    pub transform_feedback_streams_lines_triangles: Bool32,
    pub transform_feedback_rasterization_stream_select: Bool32,
    pub transform_feedback_draw: Bool32,
}

impl Default for PhysicalDeviceTransformFeedbackPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT,
            next: ptr::null_mut(),
            max_transform_feedback_streams: u32::default(),
            max_transform_feedback_buffers: u32::default(),
            max_transform_feedback_buffer_size: DeviceSize::default(),
            max_transform_feedback_stream_data_size: u32::default(),
            max_transform_feedback_buffer_data_size: u32::default(),
            max_transform_feedback_buffer_data_stride: u32::default(),
            transform_feedback_queries: Bool32::default(),
            transform_feedback_streams_lines_triangles: Bool32::default(),
            transform_feedback_rasterization_stream_select: Bool32::default(),
            transform_feedback_draw: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceUniformBufferStandardLayoutFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceUniformBufferStandardLayoutFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub uniform_buffer_standard_layout: Bool32,
}

impl Default for PhysicalDeviceUniformBufferStandardLayoutFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES,
            next: ptr::null_mut(),
            uniform_buffer_standard_layout: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVariablePointersFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVariablePointersFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub variable_pointers_storage_buffer: Bool32,
    pub variable_pointers: Bool32,
}

impl Default for PhysicalDeviceVariablePointersFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
            next: ptr::null_mut(),
            variable_pointers_storage_buffer: Bool32::default(),
            variable_pointers: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexAttributeDivisorFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVertexAttributeDivisorFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub vertex_attribute_instance_rate_divisor: Bool32,
    pub vertex_attribute_instance_rate_zero_divisor: Bool32,
}

impl Default for PhysicalDeviceVertexAttributeDivisorFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES,
            next: ptr::null_mut(),
            vertex_attribute_instance_rate_divisor: Bool32::default(),
            vertex_attribute_instance_rate_zero_divisor: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexAttributeDivisorProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVertexAttributeDivisorProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_vertex_attrib_divisor: u32,
    pub supports_non_zero_first_instance: Bool32,
}

impl Default for PhysicalDeviceVertexAttributeDivisorProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES,
            next: ptr::null_mut(),
            max_vertex_attrib_divisor: u32::default(),
            supports_non_zero_first_instance: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_vertex_attrib_divisor: u32,
}

impl Default for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT,
            next: ptr::null_mut(),
            max_vertex_attrib_divisor: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub vertex_attribute_robustness: Bool32,
}

impl Default for PhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT,
            next: ptr::null_mut(),
            vertex_attribute_robustness: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub vertex_input_dynamic_state: Bool32,
}

impl Default for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT,
            next: ptr::null_mut(),
            vertex_input_dynamic_state: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoEncodeAV1FeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVideoEncodeAV1FeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub video_encode_av1: Bool32,
}

impl Default for PhysicalDeviceVideoEncodeAV1FeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR,
            next: ptr::null_mut(),
            video_encode_av1: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub video_profile: *const VideoProfileInfoKHR,
    pub quality_level: u32,
}

impl Default for PhysicalDeviceVideoEncodeQualityLevelInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR,
            next: ptr::null(),
            video_profile: ptr::null(),
            quality_level: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub video_encode_quantization_map: Bool32,
}

impl Default for PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR,
            next: ptr::null_mut(),
            video_encode_quantization_map: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoFormatInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVideoFormatInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub image_usage: ImageUsageFlags,
}

impl Default for PhysicalDeviceVideoFormatInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR,
            next: ptr::null(),
            image_usage: ImageUsageFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoMaintenance1FeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVideoMaintenance1FeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub video_maintenance1: Bool32,
}

impl Default for PhysicalDeviceVideoMaintenance1FeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR,
            next: ptr::null_mut(),
            video_maintenance1: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoMaintenance2FeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVideoMaintenance2FeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub video_maintenance2: Bool32,
}

impl Default for PhysicalDeviceVideoMaintenance2FeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR,
            next: ptr::null_mut(),
            video_maintenance2: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan11Features.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVulkan11Features {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub storage_buffer_16bit_access: Bool32,
    pub uniform_and_storage_buffer_16bit_access: Bool32,
    pub storage_push_constant16: Bool32,
    pub storage_input_output16: Bool32,
    pub multiview: Bool32,
    pub multiview_geometry_shader: Bool32,
    pub multiview_tessellation_shader: Bool32,
    pub variable_pointers_storage_buffer: Bool32,
    pub variable_pointers: Bool32,
    pub protected_memory: Bool32,
    pub sampler_ycbcr_conversion: Bool32,
    pub shader_draw_parameters: Bool32,
}

impl Default for PhysicalDeviceVulkan11Features {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES,
            next: ptr::null_mut(),
            storage_buffer_16bit_access: Bool32::default(),
            uniform_and_storage_buffer_16bit_access: Bool32::default(),
            storage_push_constant16: Bool32::default(),
            storage_input_output16: Bool32::default(),
            multiview: Bool32::default(),
            multiview_geometry_shader: Bool32::default(),
            multiview_tessellation_shader: Bool32::default(),
            variable_pointers_storage_buffer: Bool32::default(),
            variable_pointers: Bool32::default(),
            protected_memory: Bool32::default(),
            sampler_ycbcr_conversion: Bool32::default(),
            shader_draw_parameters: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan11Properties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVulkan11Properties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub device_uuid: ByteArray<UUID_SIZE>,
    pub driver_uuid: ByteArray<UUID_SIZE>,
    pub device_luid: ByteArray<LUID_SIZE>,
    pub device_node_mask: u32,
    pub device_luid_valid: Bool32,
    pub subgroup_size: u32,
    pub subgroup_supported_stages: ShaderStageFlags,
    pub subgroup_supported_operations: SubgroupFeatureFlags,
    pub subgroup_quad_operations_in_all_stages: Bool32,
    pub point_clipping_behavior: PointClippingBehavior,
    pub max_multiview_view_count: u32,
    pub max_multiview_instance_index: u32,
    pub protected_no_fault: Bool32,
    pub max_per_set_descriptors: u32,
    pub max_memory_allocation_size: DeviceSize,
}

impl Default for PhysicalDeviceVulkan11Properties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES,
            next: ptr::null_mut(),
            device_uuid: ByteArray::default(),
            driver_uuid: ByteArray::default(),
            device_luid: ByteArray::default(),
            device_node_mask: u32::default(),
            device_luid_valid: Bool32::default(),
            subgroup_size: u32::default(),
            subgroup_supported_stages: ShaderStageFlags::default(),
            subgroup_supported_operations: SubgroupFeatureFlags::default(),
            subgroup_quad_operations_in_all_stages: Bool32::default(),
            point_clipping_behavior: PointClippingBehavior::default(),
            max_multiview_view_count: u32::default(),
            max_multiview_instance_index: u32::default(),
            protected_no_fault: Bool32::default(),
            max_per_set_descriptors: u32::default(),
            max_memory_allocation_size: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan12Features.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVulkan12Features {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub sampler_mirror_clamp_to_edge: Bool32,
    pub draw_indirect_count: Bool32,
    pub storage_buffer_8bit_access: Bool32,
    pub uniform_and_storage_buffer_8bit_access: Bool32,
    pub storage_push_constant8: Bool32,
    pub shader_buffer_int64_atomics: Bool32,
    pub shader_shared_int64_atomics: Bool32,
    pub shader_float16: Bool32,
    pub shader_int8: Bool32,
    pub descriptor_indexing: Bool32,
    pub shader_input_attachment_array_dynamic_indexing: Bool32,
    pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32,
    pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32,
    pub shader_uniform_buffer_array_non_uniform_indexing: Bool32,
    pub shader_sampled_image_array_non_uniform_indexing: Bool32,
    pub shader_storage_buffer_array_non_uniform_indexing: Bool32,
    pub shader_storage_image_array_non_uniform_indexing: Bool32,
    pub shader_input_attachment_array_non_uniform_indexing: Bool32,
    pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32,
    pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32,
    pub descriptor_binding_uniform_buffer_update_after_bind: Bool32,
    pub descriptor_binding_sampled_image_update_after_bind: Bool32,
    pub descriptor_binding_storage_image_update_after_bind: Bool32,
    pub descriptor_binding_storage_buffer_update_after_bind: Bool32,
    pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32,
    pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32,
    pub descriptor_binding_update_unused_while_pending: Bool32,
    pub descriptor_binding_partially_bound: Bool32,
    pub descriptor_binding_variable_descriptor_count: Bool32,
    pub runtime_descriptor_array: Bool32,
    pub sampler_filter_minmax: Bool32,
    pub scalar_block_layout: Bool32,
    pub imageless_framebuffer: Bool32,
    pub uniform_buffer_standard_layout: Bool32,
    pub shader_subgroup_extended_types: Bool32,
    pub separate_depth_stencil_layouts: Bool32,
    pub host_query_reset: Bool32,
    pub timeline_semaphore: Bool32,
    pub buffer_device_address: Bool32,
    pub buffer_device_address_capture_replay: Bool32,
    pub buffer_device_address_multi_device: Bool32,
    pub vulkan_memory_model: Bool32,
    pub vulkan_memory_model_device_scope: Bool32,
    pub vulkan_memory_model_availability_visibility_chains: Bool32,
    pub shader_output_viewport_index: Bool32,
    pub shader_output_layer: Bool32,
    pub subgroup_broadcast_dynamic_id: Bool32,
}

impl Default for PhysicalDeviceVulkan12Features {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
            next: ptr::null_mut(),
            sampler_mirror_clamp_to_edge: Bool32::default(),
            draw_indirect_count: Bool32::default(),
            storage_buffer_8bit_access: Bool32::default(),
            uniform_and_storage_buffer_8bit_access: Bool32::default(),
            storage_push_constant8: Bool32::default(),
            shader_buffer_int64_atomics: Bool32::default(),
            shader_shared_int64_atomics: Bool32::default(),
            shader_float16: Bool32::default(),
            shader_int8: Bool32::default(),
            descriptor_indexing: Bool32::default(),
            shader_input_attachment_array_dynamic_indexing: Bool32::default(),
            shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(),
            shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(),
            shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(),
            shader_sampled_image_array_non_uniform_indexing: Bool32::default(),
            shader_storage_buffer_array_non_uniform_indexing: Bool32::default(),
            shader_storage_image_array_non_uniform_indexing: Bool32::default(),
            shader_input_attachment_array_non_uniform_indexing: Bool32::default(),
            shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(),
            shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(),
            descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(),
            descriptor_binding_sampled_image_update_after_bind: Bool32::default(),
            descriptor_binding_storage_image_update_after_bind: Bool32::default(),
            descriptor_binding_storage_buffer_update_after_bind: Bool32::default(),
            descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(),
            descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(),
            descriptor_binding_update_unused_while_pending: Bool32::default(),
            descriptor_binding_partially_bound: Bool32::default(),
            descriptor_binding_variable_descriptor_count: Bool32::default(),
            runtime_descriptor_array: Bool32::default(),
            sampler_filter_minmax: Bool32::default(),
            scalar_block_layout: Bool32::default(),
            imageless_framebuffer: Bool32::default(),
            uniform_buffer_standard_layout: Bool32::default(),
            shader_subgroup_extended_types: Bool32::default(),
            separate_depth_stencil_layouts: Bool32::default(),
            host_query_reset: Bool32::default(),
            timeline_semaphore: Bool32::default(),
            buffer_device_address: Bool32::default(),
            buffer_device_address_capture_replay: Bool32::default(),
            buffer_device_address_multi_device: Bool32::default(),
            vulkan_memory_model: Bool32::default(),
            vulkan_memory_model_device_scope: Bool32::default(),
            vulkan_memory_model_availability_visibility_chains: Bool32::default(),
            shader_output_viewport_index: Bool32::default(),
            shader_output_layer: Bool32::default(),
            subgroup_broadcast_dynamic_id: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan12Properties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVulkan12Properties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub driver_id: DriverId,
    pub driver_name: StringArray<MAX_DRIVER_NAME_SIZE>,
    pub driver_info: StringArray<MAX_DRIVER_INFO_SIZE>,
    pub conformance_version: ConformanceVersion,
    pub denorm_behavior_independence: ShaderFloatControlsIndependence,
    pub rounding_mode_independence: ShaderFloatControlsIndependence,
    pub shader_signed_zero_inf_nan_preserve_float16: Bool32,
    pub shader_signed_zero_inf_nan_preserve_float32: Bool32,
    pub shader_signed_zero_inf_nan_preserve_float64: Bool32,
    pub shader_denorm_preserve_float16: Bool32,
    pub shader_denorm_preserve_float32: Bool32,
    pub shader_denorm_preserve_float64: Bool32,
    pub shader_denorm_flush_to_zero_float16: Bool32,
    pub shader_denorm_flush_to_zero_float32: Bool32,
    pub shader_denorm_flush_to_zero_float64: Bool32,
    pub shader_rounding_mode_rte_float16: Bool32,
    pub shader_rounding_mode_rte_float32: Bool32,
    pub shader_rounding_mode_rte_float64: Bool32,
    pub shader_rounding_mode_rtz_float16: Bool32,
    pub shader_rounding_mode_rtz_float32: Bool32,
    pub shader_rounding_mode_rtz_float64: Bool32,
    pub max_update_after_bind_descriptors_in_all_pools: u32,
    pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32,
    pub shader_sampled_image_array_non_uniform_indexing_native: Bool32,
    pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32,
    pub shader_storage_image_array_non_uniform_indexing_native: Bool32,
    pub shader_input_attachment_array_non_uniform_indexing_native: Bool32,
    pub robust_buffer_access_update_after_bind: Bool32,
    pub quad_divergent_implicit_lod: Bool32,
    pub max_per_stage_descriptor_update_after_bind_samplers: u32,
    pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
    pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
    pub max_per_stage_descriptor_update_after_bind_sampled_images: u32,
    pub max_per_stage_descriptor_update_after_bind_storage_images: u32,
    pub max_per_stage_descriptor_update_after_bind_input_attachments: u32,
    pub max_per_stage_update_after_bind_resources: u32,
    pub max_descriptor_set_update_after_bind_samplers: u32,
    pub max_descriptor_set_update_after_bind_uniform_buffers: u32,
    pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_storage_buffers: u32,
    pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_sampled_images: u32,
    pub max_descriptor_set_update_after_bind_storage_images: u32,
    pub max_descriptor_set_update_after_bind_input_attachments: u32,
    pub supported_depth_resolve_modes: ResolveModeFlags,
    pub supported_stencil_resolve_modes: ResolveModeFlags,
    pub independent_resolve_none: Bool32,
    pub independent_resolve: Bool32,
    pub filter_minmax_single_component_formats: Bool32,
    pub filter_minmax_image_component_mapping: Bool32,
    pub max_timeline_semaphore_value_difference: u64,
    pub framebuffer_integer_color_sample_counts: SampleCountFlags,
}

impl Default for PhysicalDeviceVulkan12Properties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES,
            next: ptr::null_mut(),
            driver_id: DriverId::default(),
            driver_name: StringArray::default(),
            driver_info: StringArray::default(),
            conformance_version: ConformanceVersion::default(),
            denorm_behavior_independence: ShaderFloatControlsIndependence::default(),
            rounding_mode_independence: ShaderFloatControlsIndependence::default(),
            shader_signed_zero_inf_nan_preserve_float16: Bool32::default(),
            shader_signed_zero_inf_nan_preserve_float32: Bool32::default(),
            shader_signed_zero_inf_nan_preserve_float64: Bool32::default(),
            shader_denorm_preserve_float16: Bool32::default(),
            shader_denorm_preserve_float32: Bool32::default(),
            shader_denorm_preserve_float64: Bool32::default(),
            shader_denorm_flush_to_zero_float16: Bool32::default(),
            shader_denorm_flush_to_zero_float32: Bool32::default(),
            shader_denorm_flush_to_zero_float64: Bool32::default(),
            shader_rounding_mode_rte_float16: Bool32::default(),
            shader_rounding_mode_rte_float32: Bool32::default(),
            shader_rounding_mode_rte_float64: Bool32::default(),
            shader_rounding_mode_rtz_float16: Bool32::default(),
            shader_rounding_mode_rtz_float32: Bool32::default(),
            shader_rounding_mode_rtz_float64: Bool32::default(),
            max_update_after_bind_descriptors_in_all_pools: u32::default(),
            shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(),
            shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(),
            shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(),
            shader_storage_image_array_non_uniform_indexing_native: Bool32::default(),
            shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(),
            robust_buffer_access_update_after_bind: Bool32::default(),
            quad_divergent_implicit_lod: Bool32::default(),
            max_per_stage_descriptor_update_after_bind_samplers: u32::default(),
            max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(),
            max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(),
            max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(),
            max_per_stage_descriptor_update_after_bind_storage_images: u32::default(),
            max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(),
            max_per_stage_update_after_bind_resources: u32::default(),
            max_descriptor_set_update_after_bind_samplers: u32::default(),
            max_descriptor_set_update_after_bind_uniform_buffers: u32::default(),
            max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(),
            max_descriptor_set_update_after_bind_storage_buffers: u32::default(),
            max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(),
            max_descriptor_set_update_after_bind_sampled_images: u32::default(),
            max_descriptor_set_update_after_bind_storage_images: u32::default(),
            max_descriptor_set_update_after_bind_input_attachments: u32::default(),
            supported_depth_resolve_modes: ResolveModeFlags::default(),
            supported_stencil_resolve_modes: ResolveModeFlags::default(),
            independent_resolve_none: Bool32::default(),
            independent_resolve: Bool32::default(),
            filter_minmax_single_component_formats: Bool32::default(),
            filter_minmax_image_component_mapping: Bool32::default(),
            max_timeline_semaphore_value_difference: u64::default(),
            framebuffer_integer_color_sample_counts: SampleCountFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan13Features.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVulkan13Features {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub robust_image_access: Bool32,
    pub inline_uniform_block: Bool32,
    pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32,
    pub pipeline_creation_cache_control: Bool32,
    pub private_data: Bool32,
    pub shader_demote_to_helper_invocation: Bool32,
    pub shader_terminate_invocation: Bool32,
    pub subgroup_size_control: Bool32,
    pub compute_full_subgroups: Bool32,
    pub synchronization2: Bool32,
    pub texture_compression_astc_hdr: Bool32,
    pub shader_zero_initialize_workgroup_memory: Bool32,
    pub dynamic_rendering: Bool32,
    pub shader_integer_dot_product: Bool32,
    pub maintenance4: Bool32,
}

impl Default for PhysicalDeviceVulkan13Features {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
            next: ptr::null_mut(),
            robust_image_access: Bool32::default(),
            inline_uniform_block: Bool32::default(),
            descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(),
            pipeline_creation_cache_control: Bool32::default(),
            private_data: Bool32::default(),
            shader_demote_to_helper_invocation: Bool32::default(),
            shader_terminate_invocation: Bool32::default(),
            subgroup_size_control: Bool32::default(),
            compute_full_subgroups: Bool32::default(),
            synchronization2: Bool32::default(),
            texture_compression_astc_hdr: Bool32::default(),
            shader_zero_initialize_workgroup_memory: Bool32::default(),
            dynamic_rendering: Bool32::default(),
            shader_integer_dot_product: Bool32::default(),
            maintenance4: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan13Properties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVulkan13Properties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub min_subgroup_size: u32,
    pub max_subgroup_size: u32,
    pub max_compute_workgroup_subgroups: u32,
    pub required_subgroup_size_stages: ShaderStageFlags,
    pub max_inline_uniform_block_size: u32,
    pub max_per_stage_descriptor_inline_uniform_blocks: u32,
    pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
    pub max_descriptor_set_inline_uniform_blocks: u32,
    pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
    pub max_inline_uniform_total_size: u32,
    pub integer_dot_product_8bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_8bit_signed_accelerated: Bool32,
    pub integer_dot_product_8bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product4x_8bit_packed_unsigned_accelerated: Bool32,
    pub integer_dot_product4x_8bit_packed_signed_accelerated: Bool32,
    pub integer_dot_product4x_8bit_packed_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_16bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_16bit_signed_accelerated: Bool32,
    pub integer_dot_product_16bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_32bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_32bit_signed_accelerated: Bool32,
    pub integer_dot_product_32bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_64bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_64bit_signed_accelerated: Bool32,
    pub integer_dot_product_64bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_8bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_8bit_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_8bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating4x_8bit_packed_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating4x_8bit_packed_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating4x_8bit_packed_mixed_signedness_accelerated:
        Bool32,
    pub integer_dot_product_accumulating_saturating_16bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_16bit_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_16bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_32bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_32bit_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_32bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_64bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_64bit_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating_64bit_mixed_signedness_accelerated: Bool32,
    pub storage_texel_buffer_offset_alignment_bytes: DeviceSize,
    pub storage_texel_buffer_offset_single_texel_alignment: Bool32,
    pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
    pub uniform_texel_buffer_offset_single_texel_alignment: Bool32,
    pub max_buffer_size: DeviceSize,
}

impl Default for PhysicalDeviceVulkan13Properties {
    #[inline]
    fn default() -> Self {
        Self { s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, next: ptr::null_mut(), min_subgroup_size: u32::default(), max_subgroup_size: u32::default(), max_compute_workgroup_subgroups: u32::default(), required_subgroup_size_stages: ShaderStageFlags::default(), max_inline_uniform_block_size: u32::default(), max_per_stage_descriptor_inline_uniform_blocks: u32::default(), max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32::default(), max_descriptor_set_inline_uniform_blocks: u32::default(), max_descriptor_set_update_after_bind_inline_uniform_blocks: u32::default(), max_inline_uniform_total_size: u32::default(), integer_dot_product_8bit_unsigned_accelerated: Bool32::default(), integer_dot_product_8bit_signed_accelerated: Bool32::default(), integer_dot_product_8bit_mixed_signedness_accelerated: Bool32::default(), integer_dot_product4x_8bit_packed_unsigned_accelerated: Bool32::default(), integer_dot_product4x_8bit_packed_signed_accelerated: Bool32::default(), integer_dot_product4x_8bit_packed_mixed_signedness_accelerated: Bool32::default(), integer_dot_product_16bit_unsigned_accelerated: Bool32::default(), integer_dot_product_16bit_signed_accelerated: Bool32::default(), integer_dot_product_16bit_mixed_signedness_accelerated: Bool32::default(), integer_dot_product_32bit_unsigned_accelerated: Bool32::default(), integer_dot_product_32bit_signed_accelerated: Bool32::default(), integer_dot_product_32bit_mixed_signedness_accelerated: Bool32::default(), integer_dot_product_64bit_unsigned_accelerated: Bool32::default(), integer_dot_product_64bit_signed_accelerated: Bool32::default(), integer_dot_product_64bit_mixed_signedness_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_8bit_unsigned_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_8bit_signed_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_8bit_mixed_signedness_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating4x_8bit_packed_unsigned_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating4x_8bit_packed_signed_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating4x_8bit_packed_mixed_signedness_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_16bit_unsigned_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_16bit_signed_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_16bit_mixed_signedness_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_32bit_unsigned_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_32bit_signed_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_32bit_mixed_signedness_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_64bit_unsigned_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_64bit_signed_accelerated: Bool32::default(), integer_dot_product_accumulating_saturating_64bit_mixed_signedness_accelerated: Bool32::default(), storage_texel_buffer_offset_alignment_bytes: DeviceSize::default(), storage_texel_buffer_offset_single_texel_alignment: Bool32::default(), uniform_texel_buffer_offset_alignment_bytes: DeviceSize::default(), uniform_texel_buffer_offset_single_texel_alignment: Bool32::default(), max_buffer_size: DeviceSize::default() }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan14Features.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVulkan14Features {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub global_priority_query: Bool32,
    pub shader_subgroup_rotate: Bool32,
    pub shader_subgroup_rotate_clustered: Bool32,
    pub shader_float_controls2: Bool32,
    pub shader_expect_assume: Bool32,
    pub rectangular_lines: Bool32,
    pub bresenham_lines: Bool32,
    pub smooth_lines: Bool32,
    pub stippled_rectangular_lines: Bool32,
    pub stippled_bresenham_lines: Bool32,
    pub stippled_smooth_lines: Bool32,
    pub vertex_attribute_instance_rate_divisor: Bool32,
    pub vertex_attribute_instance_rate_zero_divisor: Bool32,
    pub index_type_uint8: Bool32,
    pub dynamic_rendering_local_read: Bool32,
    pub maintenance5: Bool32,
    pub maintenance6: Bool32,
    pub pipeline_protected_access: Bool32,
    pub pipeline_robustness: Bool32,
    pub host_image_copy: Bool32,
    pub push_descriptor: Bool32,
}

impl Default for PhysicalDeviceVulkan14Features {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_4_FEATURES,
            next: ptr::null_mut(),
            global_priority_query: Bool32::default(),
            shader_subgroup_rotate: Bool32::default(),
            shader_subgroup_rotate_clustered: Bool32::default(),
            shader_float_controls2: Bool32::default(),
            shader_expect_assume: Bool32::default(),
            rectangular_lines: Bool32::default(),
            bresenham_lines: Bool32::default(),
            smooth_lines: Bool32::default(),
            stippled_rectangular_lines: Bool32::default(),
            stippled_bresenham_lines: Bool32::default(),
            stippled_smooth_lines: Bool32::default(),
            vertex_attribute_instance_rate_divisor: Bool32::default(),
            vertex_attribute_instance_rate_zero_divisor: Bool32::default(),
            index_type_uint8: Bool32::default(),
            dynamic_rendering_local_read: Bool32::default(),
            maintenance5: Bool32::default(),
            maintenance6: Bool32::default(),
            pipeline_protected_access: Bool32::default(),
            pipeline_robustness: Bool32::default(),
            host_image_copy: Bool32::default(),
            push_descriptor: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan14Properties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVulkan14Properties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub line_sub_pixel_precision_bits: u32,
    pub max_vertex_attrib_divisor: u32,
    pub supports_non_zero_first_instance: Bool32,
    pub max_push_descriptors: u32,
    pub dynamic_rendering_local_read_depth_stencil_attachments: Bool32,
    pub dynamic_rendering_local_read_multisampled_attachments: Bool32,
    pub early_fragment_multisample_coverage_after_sample_counting: Bool32,
    pub early_fragment_sample_mask_test_before_sample_counting: Bool32,
    pub depth_stencil_swizzle_one_support: Bool32,
    pub polygon_mode_point_size: Bool32,
    pub non_strict_single_pixel_wide_lines_use_parallelogram: Bool32,
    pub non_strict_wide_lines_use_parallelogram: Bool32,
    pub block_texel_view_compatible_multiple_layers: Bool32,
    pub max_combined_image_sampler_descriptor_count: u32,
    pub fragment_shading_rate_clamp_combiner_inputs: Bool32,
    pub default_robustness_storage_buffers: PipelineRobustnessBufferBehavior,
    pub default_robustness_uniform_buffers: PipelineRobustnessBufferBehavior,
    pub default_robustness_vertex_inputs: PipelineRobustnessBufferBehavior,
    pub default_robustness_images: PipelineRobustnessImageBehavior,
    pub copy_src_layout_count: u32,
    pub copy_src_layouts: *mut ImageLayout,
    pub copy_dst_layout_count: u32,
    pub copy_dst_layouts: *mut ImageLayout,
    pub optimal_tiling_layout_uuid: ByteArray<UUID_SIZE>,
    pub identical_memory_type_requirements: Bool32,
}

impl Default for PhysicalDeviceVulkan14Properties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES,
            next: ptr::null_mut(),
            line_sub_pixel_precision_bits: u32::default(),
            max_vertex_attrib_divisor: u32::default(),
            supports_non_zero_first_instance: Bool32::default(),
            max_push_descriptors: u32::default(),
            dynamic_rendering_local_read_depth_stencil_attachments: Bool32::default(),
            dynamic_rendering_local_read_multisampled_attachments: Bool32::default(),
            early_fragment_multisample_coverage_after_sample_counting: Bool32::default(),
            early_fragment_sample_mask_test_before_sample_counting: Bool32::default(),
            depth_stencil_swizzle_one_support: Bool32::default(),
            polygon_mode_point_size: Bool32::default(),
            non_strict_single_pixel_wide_lines_use_parallelogram: Bool32::default(),
            non_strict_wide_lines_use_parallelogram: Bool32::default(),
            block_texel_view_compatible_multiple_layers: Bool32::default(),
            max_combined_image_sampler_descriptor_count: u32::default(),
            fragment_shading_rate_clamp_combiner_inputs: Bool32::default(),
            default_robustness_storage_buffers: PipelineRobustnessBufferBehavior::default(),
            default_robustness_uniform_buffers: PipelineRobustnessBufferBehavior::default(),
            default_robustness_vertex_inputs: PipelineRobustnessBufferBehavior::default(),
            default_robustness_images: PipelineRobustnessImageBehavior::default(),
            copy_src_layout_count: u32::default(),
            copy_src_layouts: ptr::null_mut(),
            copy_dst_layout_count: u32::default(),
            copy_dst_layouts: ptr::null_mut(),
            optimal_tiling_layout_uuid: ByteArray::default(),
            identical_memory_type_requirements: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkanMemoryModelFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceVulkanMemoryModelFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub vulkan_memory_model: Bool32,
    pub vulkan_memory_model_device_scope: Bool32,
    pub vulkan_memory_model_availability_visibility_chains: Bool32,
}

impl Default for PhysicalDeviceVulkanMemoryModelFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES,
            next: ptr::null_mut(),
            vulkan_memory_model: Bool32::default(),
            vulkan_memory_model_device_scope: Bool32::default(),
            vulkan_memory_model_availability_visibility_chains: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub workgroup_memory_explicit_layout: Bool32,
    pub workgroup_memory_explicit_layout_scalar_block_layout: Bool32,
    pub workgroup_memory_explicit_layout_8bit_access: Bool32,
    pub workgroup_memory_explicit_layout_16bit_access: Bool32,
}

impl Default for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR,
            next: ptr::null_mut(),
            workgroup_memory_explicit_layout: Bool32::default(),
            workgroup_memory_explicit_layout_scalar_block_layout: Bool32::default(),
            workgroup_memory_explicit_layout_8bit_access: Bool32::default(),
            workgroup_memory_explicit_layout_16bit_access: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub ycbcr2plane444_formats: Bool32,
}

impl Default for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT,
            next: ptr::null_mut(),
            ycbcr2plane444_formats: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceYcbcrDegammaFeaturesQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceYcbcrDegammaFeaturesQCOM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub ycbcr_degamma: Bool32,
}

impl Default for PhysicalDeviceYcbcrDegammaFeaturesQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM,
            next: ptr::null_mut(),
            ycbcr_degamma: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub ycbcr_image_arrays: Bool32,
}

impl Default for PhysicalDeviceYcbcrImageArraysFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT,
            next: ptr::null_mut(),
            ycbcr_image_arrays: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shader_zero_initialize_workgroup_memory: Bool32,
}

impl Default for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES,
            next: ptr::null_mut(),
            shader_zero_initialize_workgroup_memory: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineBinaryCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineBinaryCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub keys_and_data_info: *const PipelineBinaryKeysAndDataKHR,
    pub pipeline: Pipeline,
    pub pipeline_create_info: *const PipelineCreateInfoKHR,
}

impl Default for PipelineBinaryCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_BINARY_CREATE_INFO_KHR,
            next: ptr::null(),
            keys_and_data_info: ptr::null(),
            pipeline: Pipeline::default(),
            pipeline_create_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineBinaryDataInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineBinaryDataInfoKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pipeline_binary: PipelineBinaryKHR,
}

impl Default for PipelineBinaryDataInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_BINARY_DATA_INFO_KHR,
            next: ptr::null_mut(),
            pipeline_binary: PipelineBinaryKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineBinaryDataKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineBinaryDataKHR {
    pub data_size: usize,
    pub data: *mut c_void,
}

impl Default for PipelineBinaryDataKHR {
    #[inline]
    fn default() -> Self {
        Self {
            data_size: usize::default(),
            data: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineBinaryHandlesInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineBinaryHandlesInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub pipeline_binary_count: u32,
    pub pipeline_binaries: *mut PipelineBinaryKHR,
}

impl Default for PipelineBinaryHandlesInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_BINARY_HANDLES_INFO_KHR,
            next: ptr::null(),
            pipeline_binary_count: u32::default(),
            pipeline_binaries: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineBinaryInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineBinaryInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub binary_count: u32,
    pub pipeline_binaries: *const PipelineBinaryKHR,
}

impl Default for PipelineBinaryInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_BINARY_INFO_KHR,
            next: ptr::null(),
            binary_count: u32::default(),
            pipeline_binaries: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineBinaryKeyKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineBinaryKeyKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub key_size: u32,
    pub key: ByteArray<MAX_PIPELINE_BINARY_KEY_SIZE_KHR>,
}

impl Default for PipelineBinaryKeyKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_BINARY_KEY_KHR,
            next: ptr::null_mut(),
            key_size: u32::default(),
            key: ByteArray::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineBinaryKeysAndDataKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineBinaryKeysAndDataKHR {
    pub binary_count: u32,
    pub pipeline_binary_keys: *const PipelineBinaryKeyKHR,
    pub pipeline_binary_data: *const PipelineBinaryDataKHR,
}

impl Default for PipelineBinaryKeysAndDataKHR {
    #[inline]
    fn default() -> Self {
        Self {
            binary_count: u32::default(),
            pipeline_binary_keys: ptr::null(),
            pipeline_binary_data: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineCacheCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineCacheCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineCacheCreateFlags,
    pub initial_data_size: usize,
    pub initial_data: *const c_void,
}

impl Default for PipelineCacheCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_CACHE_CREATE_INFO,
            next: ptr::null(),
            flags: PipelineCacheCreateFlags::default(),
            initial_data_size: usize::default(),
            initial_data: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersionOne.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct PipelineCacheHeaderVersionOne {
    pub header_size: u32,
    pub header_version: PipelineCacheHeaderVersion,
    pub vendor_id: u32,
    pub device_id: u32,
    pub pipeline_cache_uuid: ByteArray<UUID_SIZE>,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineColorBlendAdvancedStateCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineColorBlendAdvancedStateCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_premultiplied: Bool32,
    pub dst_premultiplied: Bool32,
    pub blend_overlap: BlendOverlapEXT,
}

impl Default for PipelineColorBlendAdvancedStateCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT,
            next: ptr::null(),
            src_premultiplied: Bool32::default(),
            dst_premultiplied: Bool32::default(),
            blend_overlap: BlendOverlapEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineColorBlendAttachmentState.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct PipelineColorBlendAttachmentState {
    pub blend_enable: Bool32,
    pub src_color_blend_factor: BlendFactor,
    pub dst_color_blend_factor: BlendFactor,
    pub color_blend_op: BlendOp,
    pub src_alpha_blend_factor: BlendFactor,
    pub dst_alpha_blend_factor: BlendFactor,
    pub alpha_blend_op: BlendOp,
    pub color_write_mask: ColorComponentFlags,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineColorBlendStateCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct PipelineColorBlendStateCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineColorBlendStateCreateFlags,
    pub logic_op_enable: Bool32,
    pub logic_op: LogicOp,
    pub attachment_count: u32,
    pub attachments: *const PipelineColorBlendAttachmentState,
    pub blend_constants: [f32; 4],
}

impl Default for PipelineColorBlendStateCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
            next: ptr::null(),
            flags: PipelineColorBlendStateCreateFlags::default(),
            logic_op_enable: Bool32::default(),
            logic_op: LogicOp::default(),
            attachment_count: u32::default(),
            attachments: ptr::null(),
            blend_constants: [f32::default(); 4],
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineColorWriteCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineColorWriteCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub attachment_count: u32,
    pub color_write_enables: *const Bool32,
}

impl Default for PipelineColorWriteCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_COLOR_WRITE_CREATE_INFO_EXT,
            next: ptr::null(),
            attachment_count: u32::default(),
            color_write_enables: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineCompilerControlCreateInfoAMD.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineCompilerControlCreateInfoAMD {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub compiler_control_flags: PipelineCompilerControlFlagsAMD,
}

impl Default for PipelineCompilerControlCreateInfoAMD {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD,
            next: ptr::null(),
            compiler_control_flags: PipelineCompilerControlFlagsAMD::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineCoverageModulationStateCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineCoverageModulationStateCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineCoverageModulationStateCreateFlagsNV,
    pub coverage_modulation_mode: CoverageModulationModeNV,
    pub coverage_modulation_table_enable: Bool32,
    pub coverage_modulation_table_count: u32,
    pub coverage_modulation_table: *const f32,
}

impl Default for PipelineCoverageModulationStateCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV,
            next: ptr::null(),
            flags: PipelineCoverageModulationStateCreateFlagsNV::default(),
            coverage_modulation_mode: CoverageModulationModeNV::default(),
            coverage_modulation_table_enable: Bool32::default(),
            coverage_modulation_table_count: u32::default(),
            coverage_modulation_table: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineCoverageReductionStateCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineCoverageReductionStateCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineCoverageReductionStateCreateFlagsNV,
    pub coverage_reduction_mode: CoverageReductionModeNV,
}

impl Default for PipelineCoverageReductionStateCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV,
            next: ptr::null(),
            flags: PipelineCoverageReductionStateCreateFlagsNV::default(),
            coverage_reduction_mode: CoverageReductionModeNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineCoverageToColorStateCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineCoverageToColorStateCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineCoverageToColorStateCreateFlagsNV,
    pub coverage_to_color_enable: Bool32,
    pub coverage_to_color_location: u32,
}

impl Default for PipelineCoverageToColorStateCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV,
            next: ptr::null(),
            flags: PipelineCoverageToColorStateCreateFlagsNV::default(),
            coverage_to_color_enable: Bool32::default(),
            coverage_to_color_location: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineCreateFlags2CreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineCreateFlags2CreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineCreateFlags2,
}

impl Default for PipelineCreateFlags2CreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_CREATE_FLAGS_2_CREATE_INFO,
            next: ptr::null(),
            flags: PipelineCreateFlags2::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
}

impl Default for PipelineCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_CREATE_INFO_KHR,
            next: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineCreationFeedback.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct PipelineCreationFeedback {
    pub flags: PipelineCreationFeedbackFlags,
    pub duration: u64,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineCreationFeedbackCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineCreationFeedbackCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub pipeline_creation_feedback: *mut PipelineCreationFeedback,
    pub pipeline_stage_creation_feedback_count: u32,
    pub pipeline_stage_creation_feedbacks: *mut PipelineCreationFeedback,
}

impl Default for PipelineCreationFeedbackCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_CREATION_FEEDBACK_CREATE_INFO,
            next: ptr::null(),
            pipeline_creation_feedback: ptr::null_mut(),
            pipeline_stage_creation_feedback_count: u32::default(),
            pipeline_stage_creation_feedbacks: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineDepthStencilStateCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct PipelineDepthStencilStateCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineDepthStencilStateCreateFlags,
    pub depth_test_enable: Bool32,
    pub depth_write_enable: Bool32,
    pub depth_compare_op: CompareOp,
    pub depth_bounds_test_enable: Bool32,
    pub stencil_test_enable: Bool32,
    pub front: StencilOpState,
    pub back: StencilOpState,
    pub min_depth_bounds: f32,
    pub max_depth_bounds: f32,
}

impl Default for PipelineDepthStencilStateCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
            next: ptr::null(),
            flags: PipelineDepthStencilStateCreateFlags::default(),
            depth_test_enable: Bool32::default(),
            depth_write_enable: Bool32::default(),
            depth_compare_op: CompareOp::default(),
            depth_bounds_test_enable: Bool32::default(),
            stencil_test_enable: Bool32::default(),
            front: StencilOpState::default(),
            back: StencilOpState::default(),
            min_depth_bounds: f32::default(),
            max_depth_bounds: f32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineDiscardRectangleStateCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineDiscardRectangleStateCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineDiscardRectangleStateCreateFlagsEXT,
    pub discard_rectangle_mode: DiscardRectangleModeEXT,
    pub discard_rectangle_count: u32,
    pub discard_rectangles: *const Rect2D,
}

impl Default for PipelineDiscardRectangleStateCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT,
            next: ptr::null(),
            flags: PipelineDiscardRectangleStateCreateFlagsEXT::default(),
            discard_rectangle_mode: DiscardRectangleModeEXT::default(),
            discard_rectangle_count: u32::default(),
            discard_rectangles: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineDynamicStateCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineDynamicStateCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineDynamicStateCreateFlags,
    pub dynamic_state_count: u32,
    pub dynamic_states: *const DynamicState,
}

impl Default for PipelineDynamicStateCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO,
            next: ptr::null(),
            flags: PipelineDynamicStateCreateFlags::default(),
            dynamic_state_count: u32::default(),
            dynamic_states: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineExecutableInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineExecutableInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub pipeline: Pipeline,
    pub executable_index: u32,
}

impl Default for PipelineExecutableInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_EXECUTABLE_INFO_KHR,
            next: ptr::null(),
            pipeline: Pipeline::default(),
            executable_index: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineExecutableInternalRepresentationKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineExecutableInternalRepresentationKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub name: StringArray<MAX_DESCRIPTION_SIZE>,
    pub description: StringArray<MAX_DESCRIPTION_SIZE>,
    pub is_text: Bool32,
    pub data_size: usize,
    pub data: *mut c_void,
}

impl Default for PipelineExecutableInternalRepresentationKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR,
            next: ptr::null_mut(),
            name: StringArray::default(),
            description: StringArray::default(),
            is_text: Bool32::default(),
            data_size: usize::default(),
            data: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineExecutablePropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineExecutablePropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub stages: ShaderStageFlags,
    pub name: StringArray<MAX_DESCRIPTION_SIZE>,
    pub description: StringArray<MAX_DESCRIPTION_SIZE>,
    pub subgroup_size: u32,
}

impl Default for PipelineExecutablePropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_EXECUTABLE_PROPERTIES_KHR,
            next: ptr::null_mut(),
            stages: ShaderStageFlags::default(),
            name: StringArray::default(),
            description: StringArray::default(),
            subgroup_size: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineExecutableStatisticKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineExecutableStatisticKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub name: StringArray<MAX_DESCRIPTION_SIZE>,
    pub description: StringArray<MAX_DESCRIPTION_SIZE>,
    pub format: PipelineExecutableStatisticFormatKHR,
    pub value: PipelineExecutableStatisticValueKHR,
}

impl Default for PipelineExecutableStatisticKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_EXECUTABLE_STATISTIC_KHR,
            next: ptr::null_mut(),
            name: StringArray::default(),
            description: StringArray::default(),
            format: PipelineExecutableStatisticFormatKHR::default(),
            value: PipelineExecutableStatisticValueKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineFragmentShadingRateEnumStateCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineFragmentShadingRateEnumStateCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub shading_rate_type: FragmentShadingRateTypeNV,
    pub shading_rate: FragmentShadingRateNV,
    pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2],
}

impl Default for PipelineFragmentShadingRateEnumStateCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV,
            next: ptr::null(),
            shading_rate_type: FragmentShadingRateTypeNV::default(),
            shading_rate: FragmentShadingRateNV::default(),
            combiner_ops: [FragmentShadingRateCombinerOpKHR::default(); 2],
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineFragmentShadingRateStateCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineFragmentShadingRateStateCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub fragment_size: Extent2D,
    pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2],
}

impl Default for PipelineFragmentShadingRateStateCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR,
            next: ptr::null(),
            fragment_size: Extent2D::default(),
            combiner_ops: [FragmentShadingRateCombinerOpKHR::default(); 2],
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineIndirectDeviceAddressInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineIndirectDeviceAddressInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub pipeline_bind_point: PipelineBindPoint,
    pub pipeline: Pipeline,
}

impl Default for PipelineIndirectDeviceAddressInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV,
            next: ptr::null(),
            pipeline_bind_point: PipelineBindPoint::default(),
            pipeline: Pipeline::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub pipeline: Pipeline,
}

impl Default for PipelineInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_INFO_KHR,
            next: ptr::null(),
            pipeline: Pipeline::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineInputAssemblyStateCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineInputAssemblyStateCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineInputAssemblyStateCreateFlags,
    pub topology: PrimitiveTopology,
    pub primitive_restart_enable: Bool32,
}

impl Default for PipelineInputAssemblyStateCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
            next: ptr::null(),
            flags: PipelineInputAssemblyStateCreateFlags::default(),
            topology: PrimitiveTopology::default(),
            primitive_restart_enable: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineLayoutCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineLayoutCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineLayoutCreateFlags,
    pub set_layout_count: u32,
    pub set_layouts: *const DescriptorSetLayout,
    pub push_constant_range_count: u32,
    pub push_constant_ranges: *const PushConstantRange,
}

impl Default for PipelineLayoutCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_LAYOUT_CREATE_INFO,
            next: ptr::null(),
            flags: PipelineLayoutCreateFlags::default(),
            set_layout_count: u32::default(),
            set_layouts: ptr::null(),
            push_constant_range_count: u32::default(),
            push_constant_ranges: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineLibraryCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineLibraryCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub library_count: u32,
    pub libraries: *const Pipeline,
}

impl Default for PipelineLibraryCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_LIBRARY_CREATE_INFO_KHR,
            next: ptr::null(),
            library_count: u32::default(),
            libraries: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineMultisampleStateCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct PipelineMultisampleStateCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineMultisampleStateCreateFlags,
    pub rasterization_samples: SampleCountFlags,
    pub sample_shading_enable: Bool32,
    pub min_sample_shading: f32,
    pub sample_mask: *const SampleMask,
    pub alpha_to_coverage_enable: Bool32,
    pub alpha_to_one_enable: Bool32,
}

impl Default for PipelineMultisampleStateCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
            next: ptr::null(),
            flags: PipelineMultisampleStateCreateFlags::default(),
            rasterization_samples: SampleCountFlags::default(),
            sample_shading_enable: Bool32::default(),
            min_sample_shading: f32::default(),
            sample_mask: ptr::null(),
            alpha_to_coverage_enable: Bool32::default(),
            alpha_to_one_enable: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelinePropertiesIdentifierEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelinePropertiesIdentifierEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pipeline_identifier: ByteArray<UUID_SIZE>,
}

impl Default for PipelinePropertiesIdentifierEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_PROPERTIES_IDENTIFIER_EXT,
            next: ptr::null_mut(),
            pipeline_identifier: ByteArray::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineRasterizationConservativeStateCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct PipelineRasterizationConservativeStateCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineRasterizationConservativeStateCreateFlagsEXT,
    pub conservative_rasterization_mode: ConservativeRasterizationModeEXT,
    pub extra_primitive_overestimation_size: f32,
}

impl Default for PipelineRasterizationConservativeStateCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT,
            next: ptr::null(),
            flags: PipelineRasterizationConservativeStateCreateFlagsEXT::default(),
            conservative_rasterization_mode: ConservativeRasterizationModeEXT::default(),
            extra_primitive_overestimation_size: f32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineRasterizationDepthClipStateCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineRasterizationDepthClipStateCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineRasterizationDepthClipStateCreateFlagsEXT,
    pub depth_clip_enable: Bool32,
}

impl Default for PipelineRasterizationDepthClipStateCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT,
            next: ptr::null(),
            flags: PipelineRasterizationDepthClipStateCreateFlagsEXT::default(),
            depth_clip_enable: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineRasterizationLineStateCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineRasterizationLineStateCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub line_rasterization_mode: LineRasterizationMode,
    pub stippled_line_enable: Bool32,
    pub line_stipple_factor: u32,
    pub line_stipple_pattern: u16,
}

impl Default for PipelineRasterizationLineStateCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO,
            next: ptr::null(),
            line_rasterization_mode: LineRasterizationMode::default(),
            stippled_line_enable: Bool32::default(),
            line_stipple_factor: u32::default(),
            line_stipple_pattern: u16::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineRasterizationProvokingVertexStateCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub provoking_vertex_mode: ProvokingVertexModeEXT,
}

impl Default for PipelineRasterizationProvokingVertexStateCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT,
            next: ptr::null(),
            provoking_vertex_mode: ProvokingVertexModeEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineRasterizationStateCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct PipelineRasterizationStateCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineRasterizationStateCreateFlags,
    pub depth_clamp_enable: Bool32,
    pub rasterizer_discard_enable: Bool32,
    pub polygon_mode: PolygonMode,
    pub cull_mode: CullModeFlags,
    pub front_face: FrontFace,
    pub depth_bias_enable: Bool32,
    pub depth_bias_constant_factor: f32,
    pub depth_bias_clamp: f32,
    pub depth_bias_slope_factor: f32,
    pub line_width: f32,
}

impl Default for PipelineRasterizationStateCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
            next: ptr::null(),
            flags: PipelineRasterizationStateCreateFlags::default(),
            depth_clamp_enable: Bool32::default(),
            rasterizer_discard_enable: Bool32::default(),
            polygon_mode: PolygonMode::default(),
            cull_mode: CullModeFlags::default(),
            front_face: FrontFace::default(),
            depth_bias_enable: Bool32::default(),
            depth_bias_constant_factor: f32::default(),
            depth_bias_clamp: f32::default(),
            depth_bias_slope_factor: f32::default(),
            line_width: f32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineRasterizationStateRasterizationOrderAMD.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineRasterizationStateRasterizationOrderAMD {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub rasterization_order: RasterizationOrderAMD,
}

impl Default for PipelineRasterizationStateRasterizationOrderAMD {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD,
            next: ptr::null(),
            rasterization_order: RasterizationOrderAMD::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineRasterizationStateStreamCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineRasterizationStateStreamCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineRasterizationStateStreamCreateFlagsEXT,
    pub rasterization_stream: u32,
}

impl Default for PipelineRasterizationStateStreamCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT,
            next: ptr::null(),
            flags: PipelineRasterizationStateStreamCreateFlagsEXT::default(),
            rasterization_stream: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineRenderingCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineRenderingCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub view_mask: u32,
    pub color_attachment_count: u32,
    pub color_attachment_formats: *const Format,
    pub depth_attachment_format: Format,
    pub stencil_attachment_format: Format,
}

impl Default for PipelineRenderingCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_RENDERING_CREATE_INFO,
            next: ptr::null(),
            view_mask: u32::default(),
            color_attachment_count: u32::default(),
            color_attachment_formats: ptr::null(),
            depth_attachment_format: Format::default(),
            stencil_attachment_format: Format::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineRepresentativeFragmentTestStateCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineRepresentativeFragmentTestStateCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub representative_fragment_test_enable: Bool32,
}

impl Default for PipelineRepresentativeFragmentTestStateCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV,
            next: ptr::null(),
            representative_fragment_test_enable: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineRobustnessCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineRobustnessCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub storage_buffers: PipelineRobustnessBufferBehavior,
    pub uniform_buffers: PipelineRobustnessBufferBehavior,
    pub vertex_inputs: PipelineRobustnessBufferBehavior,
    pub images: PipelineRobustnessImageBehavior,
}

impl Default for PipelineRobustnessCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_ROBUSTNESS_CREATE_INFO,
            next: ptr::null(),
            storage_buffers: PipelineRobustnessBufferBehavior::default(),
            uniform_buffers: PipelineRobustnessBufferBehavior::default(),
            vertex_inputs: PipelineRobustnessBufferBehavior::default(),
            images: PipelineRobustnessImageBehavior::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineSampleLocationsStateCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineSampleLocationsStateCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub sample_locations_enable: Bool32,
    pub sample_locations_info: SampleLocationsInfoEXT,
}

impl Default for PipelineSampleLocationsStateCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT,
            next: ptr::null(),
            sample_locations_enable: Bool32::default(),
            sample_locations_info: SampleLocationsInfoEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineShaderStageCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineShaderStageCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineShaderStageCreateFlags,
    pub stage: ShaderStageFlags,
    pub module: ShaderModule,
    pub name: *const c_char,
    pub specialization_info: *const SpecializationInfo,
}

impl Default for PipelineShaderStageCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO,
            next: ptr::null(),
            flags: PipelineShaderStageCreateFlags::default(),
            stage: ShaderStageFlags::default(),
            module: ShaderModule::default(),
            name: ptr::null(),
            specialization_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineShaderStageModuleIdentifierCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineShaderStageModuleIdentifierCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub identifier_size: u32,
    pub identifier: *const u8,
}

impl Default for PipelineShaderStageModuleIdentifierCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT,
            next: ptr::null(),
            identifier_size: u32::default(),
            identifier: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineShaderStageNodeCreateInfoAMDX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineShaderStageNodeCreateInfoAMDX {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub name: *const c_char,
    pub index: u32,
}

impl Default for PipelineShaderStageNodeCreateInfoAMDX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX,
            next: ptr::null(),
            name: ptr::null(),
            index: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineShaderStageRequiredSubgroupSizeCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfo {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub required_subgroup_size: u32,
}

impl Default for PipelineShaderStageRequiredSubgroupSizeCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO,
            next: ptr::null_mut(),
            required_subgroup_size: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineTessellationDomainOriginStateCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineTessellationDomainOriginStateCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub domain_origin: TessellationDomainOrigin,
}

impl Default for PipelineTessellationDomainOriginStateCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
            next: ptr::null(),
            domain_origin: TessellationDomainOrigin::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineTessellationStateCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineTessellationStateCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineTessellationStateCreateFlags,
    pub patch_control_points: u32,
}

impl Default for PipelineTessellationStateCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_TESSELLATION_STATE_CREATE_INFO,
            next: ptr::null(),
            flags: PipelineTessellationStateCreateFlags::default(),
            patch_control_points: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineVertexInputDivisorStateCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineVertexInputDivisorStateCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub vertex_binding_divisor_count: u32,
    pub vertex_binding_divisors: *const VertexInputBindingDivisorDescription,
}

impl Default for PipelineVertexInputDivisorStateCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO,
            next: ptr::null(),
            vertex_binding_divisor_count: u32::default(),
            vertex_binding_divisors: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineVertexInputStateCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineVertexInputStateCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineVertexInputStateCreateFlags,
    pub vertex_binding_description_count: u32,
    pub vertex_binding_descriptions: *const VertexInputBindingDescription,
    pub vertex_attribute_description_count: u32,
    pub vertex_attribute_descriptions: *const VertexInputAttributeDescription,
}

impl Default for PipelineVertexInputStateCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
            next: ptr::null(),
            flags: PipelineVertexInputStateCreateFlags::default(),
            vertex_binding_description_count: u32::default(),
            vertex_binding_descriptions: ptr::null(),
            vertex_attribute_description_count: u32::default(),
            vertex_attribute_descriptions: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub sample_order_type: CoarseSampleOrderTypeNV,
    pub custom_sample_order_count: u32,
    pub custom_sample_orders: *const CoarseSampleOrderCustomNV,
}

impl Default for PipelineViewportCoarseSampleOrderStateCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV,
            next: ptr::null(),
            sample_order_type: CoarseSampleOrderTypeNV::default(),
            custom_sample_order_count: u32::default(),
            custom_sample_orders: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineViewportDepthClampControlCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineViewportDepthClampControlCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub depth_clamp_mode: DepthClampModeEXT,
    pub depth_clamp_range: *const DepthClampRangeEXT,
}

impl Default for PipelineViewportDepthClampControlCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT,
            next: ptr::null(),
            depth_clamp_mode: DepthClampModeEXT::default(),
            depth_clamp_range: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineViewportDepthClipControlCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineViewportDepthClipControlCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub negative_one_to_one: Bool32,
}

impl Default for PipelineViewportDepthClipControlCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT,
            next: ptr::null(),
            negative_one_to_one: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineViewportExclusiveScissorStateCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineViewportExclusiveScissorStateCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub exclusive_scissor_count: u32,
    pub exclusive_scissors: *const Rect2D,
}

impl Default for PipelineViewportExclusiveScissorStateCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV,
            next: ptr::null(),
            exclusive_scissor_count: u32::default(),
            exclusive_scissors: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineViewportShadingRateImageStateCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineViewportShadingRateImageStateCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub shading_rate_image_enable: Bool32,
    pub viewport_count: u32,
    pub shading_rate_palettes: *const ShadingRatePaletteNV,
}

impl Default for PipelineViewportShadingRateImageStateCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV,
            next: ptr::null(),
            shading_rate_image_enable: Bool32::default(),
            viewport_count: u32::default(),
            shading_rate_palettes: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineViewportStateCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineViewportStateCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineViewportStateCreateFlags,
    pub viewport_count: u32,
    pub viewports: *const Viewport,
    pub scissor_count: u32,
    pub scissors: *const Rect2D,
}

impl Default for PipelineViewportStateCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO,
            next: ptr::null(),
            flags: PipelineViewportStateCreateFlags::default(),
            viewport_count: u32::default(),
            viewports: ptr::null(),
            scissor_count: u32::default(),
            scissors: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineViewportSwizzleStateCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineViewportSwizzleStateCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineViewportSwizzleStateCreateFlagsNV,
    pub viewport_count: u32,
    pub viewport_swizzles: *const ViewportSwizzleNV,
}

impl Default for PipelineViewportSwizzleStateCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV,
            next: ptr::null(),
            flags: PipelineViewportSwizzleStateCreateFlagsNV::default(),
            viewport_count: u32::default(),
            viewport_swizzles: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineViewportWScalingStateCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PipelineViewportWScalingStateCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub viewport_w_scaling_enable: Bool32,
    pub viewport_count: u32,
    pub viewport_w_scalings: *const ViewportWScalingNV,
}

impl Default for PipelineViewportWScalingStateCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV,
            next: ptr::null(),
            viewport_w_scaling_enable: Bool32::default(),
            viewport_count: u32::default(),
            viewport_w_scalings: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPresentFrameTokenGGP.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PresentFrameTokenGGP {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub frame_token: GgpFrameToken,
}

impl Default for PresentFrameTokenGGP {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PRESENT_FRAME_TOKEN_GGP,
            next: ptr::null(),
            frame_token: GgpFrameToken::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPresentIdKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PresentIdKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub swapchain_count: u32,
    pub present_ids: *const u64,
}

impl Default for PresentIdKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PRESENT_ID_KHR,
            next: ptr::null(),
            swapchain_count: u32::default(),
            present_ids: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPresentInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PresentInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub wait_semaphore_count: u32,
    pub wait_semaphores: *const Semaphore,
    pub swapchain_count: u32,
    pub swapchains: *const SwapchainKHR,
    pub image_indices: *const u32,
    pub results: *mut Result,
}

impl Default for PresentInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PRESENT_INFO_KHR,
            next: ptr::null(),
            wait_semaphore_count: u32::default(),
            wait_semaphores: ptr::null(),
            swapchain_count: u32::default(),
            swapchains: ptr::null(),
            image_indices: ptr::null(),
            results: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPresentRegionKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PresentRegionKHR {
    pub rectangle_count: u32,
    pub rectangles: *const RectLayerKHR,
}

impl Default for PresentRegionKHR {
    #[inline]
    fn default() -> Self {
        Self {
            rectangle_count: u32::default(),
            rectangles: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPresentRegionsKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PresentRegionsKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub swapchain_count: u32,
    pub regions: *const PresentRegionKHR,
}

impl Default for PresentRegionsKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PRESENT_REGIONS_KHR,
            next: ptr::null(),
            swapchain_count: u32::default(),
            regions: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPresentTimeGOOGLE.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct PresentTimeGOOGLE {
    pub present_id: u32,
    pub desired_present_time: u64,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPresentTimesInfoGOOGLE.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PresentTimesInfoGOOGLE {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub swapchain_count: u32,
    pub times: *const PresentTimeGOOGLE,
}

impl Default for PresentTimesInfoGOOGLE {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PRESENT_TIMES_INFO_GOOGLE,
            next: ptr::null(),
            swapchain_count: u32::default(),
            times: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPrivateDataSlotCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PrivateDataSlotCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PrivateDataSlotCreateFlags,
}

impl Default for PrivateDataSlotCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PRIVATE_DATA_SLOT_CREATE_INFO,
            next: ptr::null(),
            flags: PrivateDataSlotCreateFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkProtectedSubmitInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ProtectedSubmitInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub protected_submit: Bool32,
}

impl Default for ProtectedSubmitInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PROTECTED_SUBMIT_INFO,
            next: ptr::null(),
            protected_submit: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPushConstantRange.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct PushConstantRange {
    pub stage_flags: ShaderStageFlags,
    pub offset: u32,
    pub size: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPushConstantsInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PushConstantsInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub layout: PipelineLayout,
    pub stage_flags: ShaderStageFlags,
    pub offset: u32,
    pub size: u32,
    pub values: *const c_void,
}

impl Default for PushConstantsInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PUSH_CONSTANTS_INFO,
            next: ptr::null(),
            layout: PipelineLayout::default(),
            stage_flags: ShaderStageFlags::default(),
            offset: u32::default(),
            size: u32::default(),
            values: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPushDescriptorSetInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PushDescriptorSetInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub stage_flags: ShaderStageFlags,
    pub layout: PipelineLayout,
    pub set: u32,
    pub descriptor_write_count: u32,
    pub descriptor_writes: *const WriteDescriptorSet,
}

impl Default for PushDescriptorSetInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PUSH_DESCRIPTOR_SET_INFO,
            next: ptr::null(),
            stage_flags: ShaderStageFlags::default(),
            layout: PipelineLayout::default(),
            set: u32::default(),
            descriptor_write_count: u32::default(),
            descriptor_writes: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPushDescriptorSetWithTemplateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct PushDescriptorSetWithTemplateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub descriptor_update_template: DescriptorUpdateTemplate,
    pub layout: PipelineLayout,
    pub set: u32,
    pub data: *const c_void,
}

impl Default for PushDescriptorSetWithTemplateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO,
            next: ptr::null(),
            descriptor_update_template: DescriptorUpdateTemplate::default(),
            layout: PipelineLayout::default(),
            set: u32::default(),
            data: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkQueryLowLatencySupportNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct QueryLowLatencySupportNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub queried_low_latency_data: *mut c_void,
}

impl Default for QueryLowLatencySupportNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::QUERY_LOW_LATENCY_SUPPORT_NV,
            next: ptr::null(),
            queried_low_latency_data: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkQueryPoolCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct QueryPoolCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: QueryPoolCreateFlags,
    pub query_type: QueryType,
    pub query_count: u32,
    pub pipeline_statistics: QueryPipelineStatisticFlags,
}

impl Default for QueryPoolCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::QUERY_POOL_CREATE_INFO,
            next: ptr::null(),
            flags: QueryPoolCreateFlags::default(),
            query_type: QueryType::default(),
            query_count: u32::default(),
            pipeline_statistics: QueryPipelineStatisticFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkQueryPoolPerformanceCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct QueryPoolPerformanceCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub queue_family_index: u32,
    pub counter_index_count: u32,
    pub counter_indices: *const u32,
}

impl Default for QueryPoolPerformanceCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR,
            next: ptr::null(),
            queue_family_index: u32::default(),
            counter_index_count: u32::default(),
            counter_indices: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkQueryPoolPerformanceQueryCreateInfoINTEL.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct QueryPoolPerformanceQueryCreateInfoINTEL {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub performance_counters_sampling: QueryPoolSamplingModeINTEL,
}

impl Default for QueryPoolPerformanceQueryCreateInfoINTEL {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL,
            next: ptr::null(),
            performance_counters_sampling: QueryPoolSamplingModeINTEL::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkQueryPoolVideoEncodeFeedbackCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct QueryPoolVideoEncodeFeedbackCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub encode_feedback_flags: VideoEncodeFeedbackFlagsKHR,
}

impl Default for QueryPoolVideoEncodeFeedbackCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR,
            next: ptr::null(),
            encode_feedback_flags: VideoEncodeFeedbackFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkQueueFamilyCheckpointProperties2NV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct QueueFamilyCheckpointProperties2NV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub checkpoint_execution_stage_mask: PipelineStageFlags2,
}

impl Default for QueueFamilyCheckpointProperties2NV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV,
            next: ptr::null_mut(),
            checkpoint_execution_stage_mask: PipelineStageFlags2::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkQueueFamilyCheckpointPropertiesNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct QueueFamilyCheckpointPropertiesNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub checkpoint_execution_stage_mask: PipelineStageFlags,
}

impl Default for QueueFamilyCheckpointPropertiesNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV,
            next: ptr::null_mut(),
            checkpoint_execution_stage_mask: PipelineStageFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkQueueFamilyGlobalPriorityProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct QueueFamilyGlobalPriorityProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub priority_count: u32,
    pub priorities: [QueueGlobalPriority; MAX_GLOBAL_PRIORITY_SIZE],
}

impl Default for QueueFamilyGlobalPriorityProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES,
            next: ptr::null_mut(),
            priority_count: u32::default(),
            priorities: [QueueGlobalPriority::default(); MAX_GLOBAL_PRIORITY_SIZE],
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkQueueFamilyProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct QueueFamilyProperties {
    pub queue_flags: QueueFlags,
    pub queue_count: u32,
    pub timestamp_valid_bits: u32,
    pub min_image_transfer_granularity: Extent3D,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkQueueFamilyProperties2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct QueueFamilyProperties2 {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub queue_family_properties: QueueFamilyProperties,
}

impl Default for QueueFamilyProperties2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::QUEUE_FAMILY_PROPERTIES_2,
            next: ptr::null_mut(),
            queue_family_properties: QueueFamilyProperties::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkQueueFamilyQueryResultStatusPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct QueueFamilyQueryResultStatusPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub query_result_status_support: Bool32,
}

impl Default for QueueFamilyQueryResultStatusPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR,
            next: ptr::null_mut(),
            query_result_status_support: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkQueueFamilyVideoPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct QueueFamilyVideoPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub video_codec_operations: VideoCodecOperationFlagsKHR,
}

impl Default for QueueFamilyVideoPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::QUEUE_FAMILY_VIDEO_PROPERTIES_KHR,
            next: ptr::null_mut(),
            video_codec_operations: VideoCodecOperationFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RayTracingPipelineClusterAccelerationStructureCreateInfoNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub allow_cluster_acceleration_structure: Bool32,
}

impl Default for RayTracingPipelineClusterAccelerationStructureCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type:
                StructureType::RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV,
            next: ptr::null_mut(),
            allow_cluster_acceleration_structure: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRayTracingPipelineCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RayTracingPipelineCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineCreateFlags,
    pub stage_count: u32,
    pub stages: *const PipelineShaderStageCreateInfo,
    pub group_count: u32,
    pub groups: *const RayTracingShaderGroupCreateInfoKHR,
    pub max_pipeline_ray_recursion_depth: u32,
    pub library_info: *const PipelineLibraryCreateInfoKHR,
    pub library_interface: *const RayTracingPipelineInterfaceCreateInfoKHR,
    pub dynamic_state: *const PipelineDynamicStateCreateInfo,
    pub layout: PipelineLayout,
    pub base_pipeline_handle: Pipeline,
    pub base_pipeline_index: i32,
}

impl Default for RayTracingPipelineCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_KHR,
            next: ptr::null(),
            flags: PipelineCreateFlags::default(),
            stage_count: u32::default(),
            stages: ptr::null(),
            group_count: u32::default(),
            groups: ptr::null(),
            max_pipeline_ray_recursion_depth: u32::default(),
            library_info: ptr::null(),
            library_interface: ptr::null(),
            dynamic_state: ptr::null(),
            layout: PipelineLayout::default(),
            base_pipeline_handle: Pipeline::default(),
            base_pipeline_index: i32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRayTracingPipelineCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RayTracingPipelineCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: PipelineCreateFlags,
    pub stage_count: u32,
    pub stages: *const PipelineShaderStageCreateInfo,
    pub group_count: u32,
    pub groups: *const RayTracingShaderGroupCreateInfoNV,
    pub max_recursion_depth: u32,
    pub layout: PipelineLayout,
    pub base_pipeline_handle: Pipeline,
    pub base_pipeline_index: i32,
}

impl Default for RayTracingPipelineCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_NV,
            next: ptr::null(),
            flags: PipelineCreateFlags::default(),
            stage_count: u32::default(),
            stages: ptr::null(),
            group_count: u32::default(),
            groups: ptr::null(),
            max_recursion_depth: u32::default(),
            layout: PipelineLayout::default(),
            base_pipeline_handle: Pipeline::default(),
            base_pipeline_index: i32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRayTracingPipelineInterfaceCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RayTracingPipelineInterfaceCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub max_pipeline_ray_payload_size: u32,
    pub max_pipeline_ray_hit_attribute_size: u32,
}

impl Default for RayTracingPipelineInterfaceCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR,
            next: ptr::null(),
            max_pipeline_ray_payload_size: u32::default(),
            max_pipeline_ray_hit_attribute_size: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRayTracingShaderGroupCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RayTracingShaderGroupCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub type_: RayTracingShaderGroupTypeKHR,
    pub general_shader: u32,
    pub closest_hit_shader: u32,
    pub any_hit_shader: u32,
    pub intersection_shader: u32,
    pub shader_group_capture_replay_handle: *const c_void,
}

impl Default for RayTracingShaderGroupCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
            next: ptr::null(),
            type_: RayTracingShaderGroupTypeKHR::default(),
            general_shader: u32::default(),
            closest_hit_shader: u32::default(),
            any_hit_shader: u32::default(),
            intersection_shader: u32::default(),
            shader_group_capture_replay_handle: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRayTracingShaderGroupCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RayTracingShaderGroupCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub type_: RayTracingShaderGroupTypeKHR,
    pub general_shader: u32,
    pub closest_hit_shader: u32,
    pub any_hit_shader: u32,
    pub intersection_shader: u32,
}

impl Default for RayTracingShaderGroupCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV,
            next: ptr::null(),
            type_: RayTracingShaderGroupTypeKHR::default(),
            general_shader: u32::default(),
            closest_hit_shader: u32::default(),
            any_hit_shader: u32::default(),
            intersection_shader: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRect2D.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct Rect2D {
    pub offset: Offset2D,
    pub extent: Extent2D,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRectLayerKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct RectLayerKHR {
    pub offset: Offset2D,
    pub extent: Extent2D,
    pub layer: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRefreshCycleDurationGOOGLE.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct RefreshCycleDurationGOOGLE {
    pub refresh_duration: u64,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRefreshObjectKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct RefreshObjectKHR {
    pub object_type: ObjectType,
    pub object_handle: u64,
    pub flags: RefreshObjectFlagsKHR,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRefreshObjectListKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RefreshObjectListKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub object_count: u32,
    pub objects: *const RefreshObjectKHR,
}

impl Default for RefreshObjectListKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::REFRESH_OBJECT_LIST_KHR,
            next: ptr::null(),
            object_count: u32::default(),
            objects: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkReleaseCapturedPipelineDataInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ReleaseCapturedPipelineDataInfoKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub pipeline: Pipeline,
}

impl Default for ReleaseCapturedPipelineDataInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR,
            next: ptr::null_mut(),
            pipeline: Pipeline::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkReleaseSwapchainImagesInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ReleaseSwapchainImagesInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub swapchain: SwapchainKHR,
    pub image_index_count: u32,
    pub image_indices: *const u32,
}

impl Default for ReleaseSwapchainImagesInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RELEASE_SWAPCHAIN_IMAGES_INFO_EXT,
            next: ptr::null(),
            swapchain: SwapchainKHR::default(),
            image_index_count: u32::default(),
            image_indices: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassAttachmentBeginInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassAttachmentBeginInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub attachment_count: u32,
    pub attachments: *const ImageView,
}

impl Default for RenderPassAttachmentBeginInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDER_PASS_ATTACHMENT_BEGIN_INFO,
            next: ptr::null(),
            attachment_count: u32::default(),
            attachments: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassBeginInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassBeginInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub render_pass: RenderPass,
    pub framebuffer: Framebuffer,
    pub render_area: Rect2D,
    pub clear_value_count: u32,
    pub clear_values: *const ClearValue,
}

impl Default for RenderPassBeginInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDER_PASS_BEGIN_INFO,
            next: ptr::null(),
            render_pass: RenderPass::default(),
            framebuffer: Framebuffer::default(),
            render_area: Rect2D::default(),
            clear_value_count: u32::default(),
            clear_values: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: RenderPassCreateFlags,
    pub attachment_count: u32,
    pub attachments: *const AttachmentDescription,
    pub subpass_count: u32,
    pub subpasses: *const SubpassDescription,
    pub dependency_count: u32,
    pub dependencies: *const SubpassDependency,
}

impl Default for RenderPassCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDER_PASS_CREATE_INFO,
            next: ptr::null(),
            flags: RenderPassCreateFlags::default(),
            attachment_count: u32::default(),
            attachments: ptr::null(),
            subpass_count: u32::default(),
            subpasses: ptr::null(),
            dependency_count: u32::default(),
            dependencies: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassCreateInfo2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassCreateInfo2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: RenderPassCreateFlags,
    pub attachment_count: u32,
    pub attachments: *const AttachmentDescription2,
    pub subpass_count: u32,
    pub subpasses: *const SubpassDescription2,
    pub dependency_count: u32,
    pub dependencies: *const SubpassDependency2,
    pub correlated_view_mask_count: u32,
    pub correlated_view_masks: *const u32,
}

impl Default for RenderPassCreateInfo2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDER_PASS_CREATE_INFO_2,
            next: ptr::null(),
            flags: RenderPassCreateFlags::default(),
            attachment_count: u32::default(),
            attachments: ptr::null(),
            subpass_count: u32::default(),
            subpasses: ptr::null(),
            dependency_count: u32::default(),
            dependencies: ptr::null(),
            correlated_view_mask_count: u32::default(),
            correlated_view_masks: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassCreationControlEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassCreationControlEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub disallow_merging: Bool32,
}

impl Default for RenderPassCreationControlEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDER_PASS_CREATION_CONTROL_EXT,
            next: ptr::null(),
            disallow_merging: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassCreationFeedbackCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassCreationFeedbackCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub render_pass_feedback: *mut RenderPassCreationFeedbackInfoEXT,
}

impl Default for RenderPassCreationFeedbackCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT,
            next: ptr::null(),
            render_pass_feedback: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassCreationFeedbackInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassCreationFeedbackInfoEXT {
    pub post_merge_subpass_count: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassFragmentDensityMapCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassFragmentDensityMapCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub fragment_density_map_attachment: AttachmentReference,
}

impl Default for RenderPassFragmentDensityMapCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT,
            next: ptr::null(),
            fragment_density_map_attachment: AttachmentReference::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassInputAttachmentAspectCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassInputAttachmentAspectCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub aspect_reference_count: u32,
    pub aspect_references: *const InputAttachmentAspectReference,
}

impl Default for RenderPassInputAttachmentAspectCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
            next: ptr::null(),
            aspect_reference_count: u32::default(),
            aspect_references: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassMultiviewCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassMultiviewCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub subpass_count: u32,
    pub view_masks: *const u32,
    pub dependency_count: u32,
    pub view_offsets: *const i32,
    pub correlation_mask_count: u32,
    pub correlation_masks: *const u32,
}

impl Default for RenderPassMultiviewCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDER_PASS_MULTIVIEW_CREATE_INFO,
            next: ptr::null(),
            subpass_count: u32::default(),
            view_masks: ptr::null(),
            dependency_count: u32::default(),
            view_offsets: ptr::null(),
            correlation_mask_count: u32::default(),
            correlation_masks: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassSampleLocationsBeginInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassSampleLocationsBeginInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub attachment_initial_sample_locations_count: u32,
    pub attachment_initial_sample_locations: *const AttachmentSampleLocationsEXT,
    pub post_subpass_sample_locations_count: u32,
    pub post_subpass_sample_locations: *const SubpassSampleLocationsEXT,
}

impl Default for RenderPassSampleLocationsBeginInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT,
            next: ptr::null(),
            attachment_initial_sample_locations_count: u32::default(),
            attachment_initial_sample_locations: ptr::null(),
            post_subpass_sample_locations_count: u32::default(),
            post_subpass_sample_locations: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassStripeBeginInfoARM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassStripeBeginInfoARM {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub stripe_info_count: u32,
    pub stripe_infos: *const RenderPassStripeInfoARM,
}

impl Default for RenderPassStripeBeginInfoARM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDER_PASS_STRIPE_BEGIN_INFO_ARM,
            next: ptr::null(),
            stripe_info_count: u32::default(),
            stripe_infos: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassStripeInfoARM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassStripeInfoARM {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub stripe_area: Rect2D,
}

impl Default for RenderPassStripeInfoARM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDER_PASS_STRIPE_INFO_ARM,
            next: ptr::null(),
            stripe_area: Rect2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassStripeSubmitInfoARM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassStripeSubmitInfoARM {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub stripe_semaphore_info_count: u32,
    pub stripe_semaphore_infos: *const SemaphoreSubmitInfo,
}

impl Default for RenderPassStripeSubmitInfoARM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDER_PASS_STRIPE_SUBMIT_INFO_ARM,
            next: ptr::null(),
            stripe_semaphore_info_count: u32::default(),
            stripe_semaphore_infos: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassSubpassFeedbackCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassSubpassFeedbackCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub subpass_feedback: *mut RenderPassSubpassFeedbackInfoEXT,
}

impl Default for RenderPassSubpassFeedbackCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT,
            next: ptr::null(),
            subpass_feedback: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassSubpassFeedbackInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassSubpassFeedbackInfoEXT {
    pub subpass_merge_status: SubpassMergeStatusEXT,
    pub description: StringArray<MAX_DESCRIPTION_SIZE>,
    pub post_merge_index: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassTransformBeginInfoQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderPassTransformBeginInfoQCOM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub transform: SurfaceTransformFlagsKHR,
}

impl Default for RenderPassTransformBeginInfoQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM,
            next: ptr::null_mut(),
            transform: SurfaceTransformFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderingAreaInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderingAreaInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub view_mask: u32,
    pub color_attachment_count: u32,
    pub color_attachment_formats: *const Format,
    pub depth_attachment_format: Format,
    pub stencil_attachment_format: Format,
}

impl Default for RenderingAreaInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDERING_AREA_INFO,
            next: ptr::null(),
            view_mask: u32::default(),
            color_attachment_count: u32::default(),
            color_attachment_formats: ptr::null(),
            depth_attachment_format: Format::default(),
            stencil_attachment_format: Format::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderingAttachmentInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderingAttachmentInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub image_view: ImageView,
    pub image_layout: ImageLayout,
    pub resolve_mode: ResolveModeFlags,
    pub resolve_image_view: ImageView,
    pub resolve_image_layout: ImageLayout,
    pub load_op: AttachmentLoadOp,
    pub store_op: AttachmentStoreOp,
    pub clear_value: ClearValue,
}

impl Default for RenderingAttachmentInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDERING_ATTACHMENT_INFO,
            next: ptr::null(),
            image_view: ImageView::default(),
            image_layout: ImageLayout::default(),
            resolve_mode: ResolveModeFlags::default(),
            resolve_image_view: ImageView::default(),
            resolve_image_layout: ImageLayout::default(),
            load_op: AttachmentLoadOp::default(),
            store_op: AttachmentStoreOp::default(),
            clear_value: ClearValue::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderingAttachmentLocationInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderingAttachmentLocationInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub color_attachment_count: u32,
    pub color_attachment_locations: *const u32,
}

impl Default for RenderingAttachmentLocationInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDERING_ATTACHMENT_LOCATION_INFO,
            next: ptr::null(),
            color_attachment_count: u32::default(),
            color_attachment_locations: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderingFragmentDensityMapAttachmentInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderingFragmentDensityMapAttachmentInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub image_view: ImageView,
    pub image_layout: ImageLayout,
}

impl Default for RenderingFragmentDensityMapAttachmentInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT,
            next: ptr::null(),
            image_view: ImageView::default(),
            image_layout: ImageLayout::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderingFragmentShadingRateAttachmentInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderingFragmentShadingRateAttachmentInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub image_view: ImageView,
    pub image_layout: ImageLayout,
    pub shading_rate_attachment_texel_size: Extent2D,
}

impl Default for RenderingFragmentShadingRateAttachmentInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR,
            next: ptr::null(),
            image_view: ImageView::default(),
            image_layout: ImageLayout::default(),
            shading_rate_attachment_texel_size: Extent2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderingInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderingInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: RenderingFlags,
    pub render_area: Rect2D,
    pub layer_count: u32,
    pub view_mask: u32,
    pub color_attachment_count: u32,
    pub color_attachments: *const RenderingAttachmentInfo,
    pub depth_attachment: *const RenderingAttachmentInfo,
    pub stencil_attachment: *const RenderingAttachmentInfo,
}

impl Default for RenderingInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDERING_INFO,
            next: ptr::null(),
            flags: RenderingFlags::default(),
            render_area: Rect2D::default(),
            layer_count: u32::default(),
            view_mask: u32::default(),
            color_attachment_count: u32::default(),
            color_attachments: ptr::null(),
            depth_attachment: ptr::null(),
            stencil_attachment: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderingInputAttachmentIndexInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct RenderingInputAttachmentIndexInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub color_attachment_count: u32,
    pub color_attachment_input_indices: *const u32,
    pub depth_input_attachment_index: *const u32,
    pub stencil_input_attachment_index: *const u32,
}

impl Default for RenderingInputAttachmentIndexInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RENDERING_INPUT_ATTACHMENT_INDEX_INFO,
            next: ptr::null(),
            color_attachment_count: u32::default(),
            color_attachment_input_indices: ptr::null(),
            depth_input_attachment_index: ptr::null(),
            stencil_input_attachment_index: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkResolveImageInfo2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ResolveImageInfo2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_image: Image,
    pub src_image_layout: ImageLayout,
    pub dst_image: Image,
    pub dst_image_layout: ImageLayout,
    pub region_count: u32,
    pub regions: *const ImageResolve2,
}

impl Default for ResolveImageInfo2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::RESOLVE_IMAGE_INFO_2,
            next: ptr::null(),
            src_image: Image::default(),
            src_image_layout: ImageLayout::default(),
            dst_image: Image::default(),
            dst_image_layout: ImageLayout::default(),
            region_count: u32::default(),
            regions: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSRTDataNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq)]
pub struct SRTDataNV {
    pub sx: f32,
    pub a: f32,
    pub b: f32,
    pub pvx: f32,
    pub sy: f32,
    pub c: f32,
    pub pvy: f32,
    pub sz: f32,
    pub pvz: f32,
    pub qx: f32,
    pub qy: f32,
    pub qz: f32,
    pub qw: f32,
    pub tx: f32,
    pub ty: f32,
    pub tz: f32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSampleLocationEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq)]
pub struct SampleLocationEXT {
    pub x: f32,
    pub y: f32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSampleLocationsInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SampleLocationsInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub sample_locations_per_pixel: SampleCountFlags,
    pub sample_location_grid_size: Extent2D,
    pub sample_locations_count: u32,
    pub sample_locations: *const SampleLocationEXT,
}

impl Default for SampleLocationsInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SAMPLE_LOCATIONS_INFO_EXT,
            next: ptr::null(),
            sample_locations_per_pixel: SampleCountFlags::default(),
            sample_location_grid_size: Extent2D::default(),
            sample_locations_count: u32::default(),
            sample_locations: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSamplerBlockMatchWindowCreateInfoQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SamplerBlockMatchWindowCreateInfoQCOM {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub window_extent: Extent2D,
    pub window_compare_mode: BlockMatchWindowCompareModeQCOM,
}

impl Default for SamplerBlockMatchWindowCreateInfoQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM,
            next: ptr::null(),
            window_extent: Extent2D::default(),
            window_compare_mode: BlockMatchWindowCompareModeQCOM::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSamplerBorderColorComponentMappingCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SamplerBorderColorComponentMappingCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub components: ComponentMapping,
    pub srgb: Bool32,
}

impl Default for SamplerBorderColorComponentMappingCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT,
            next: ptr::null(),
            components: ComponentMapping::default(),
            srgb: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSamplerCaptureDescriptorDataInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SamplerCaptureDescriptorDataInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub sampler: Sampler,
}

impl Default for SamplerCaptureDescriptorDataInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT,
            next: ptr::null(),
            sampler: Sampler::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSamplerCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct SamplerCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: SamplerCreateFlags,
    pub mag_filter: Filter,
    pub min_filter: Filter,
    pub mipmap_mode: SamplerMipmapMode,
    pub address_mode_u: SamplerAddressMode,
    pub address_mode_v: SamplerAddressMode,
    pub address_mode_w: SamplerAddressMode,
    pub mip_lod_bias: f32,
    pub anisotropy_enable: Bool32,
    pub max_anisotropy: f32,
    pub compare_enable: Bool32,
    pub compare_op: CompareOp,
    pub min_lod: f32,
    pub max_lod: f32,
    pub border_color: BorderColor,
    pub unnormalized_coordinates: Bool32,
}

impl Default for SamplerCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SAMPLER_CREATE_INFO,
            next: ptr::null(),
            flags: SamplerCreateFlags::default(),
            mag_filter: Filter::default(),
            min_filter: Filter::default(),
            mipmap_mode: SamplerMipmapMode::default(),
            address_mode_u: SamplerAddressMode::default(),
            address_mode_v: SamplerAddressMode::default(),
            address_mode_w: SamplerAddressMode::default(),
            mip_lod_bias: f32::default(),
            anisotropy_enable: Bool32::default(),
            max_anisotropy: f32::default(),
            compare_enable: Bool32::default(),
            compare_op: CompareOp::default(),
            min_lod: f32::default(),
            max_lod: f32::default(),
            border_color: BorderColor::default(),
            unnormalized_coordinates: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSamplerCubicWeightsCreateInfoQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SamplerCubicWeightsCreateInfoQCOM {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub cubic_weights: CubicFilterWeightsQCOM,
}

impl Default for SamplerCubicWeightsCreateInfoQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM,
            next: ptr::null(),
            cubic_weights: CubicFilterWeightsQCOM::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSamplerCustomBorderColorCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SamplerCustomBorderColorCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub custom_border_color: ClearColorValue,
    pub format: Format,
}

impl Default for SamplerCustomBorderColorCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT,
            next: ptr::null(),
            custom_border_color: ClearColorValue::default(),
            format: Format::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSamplerReductionModeCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SamplerReductionModeCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub reduction_mode: SamplerReductionMode,
}

impl Default for SamplerReductionModeCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SAMPLER_REDUCTION_MODE_CREATE_INFO,
            next: ptr::null(),
            reduction_mode: SamplerReductionMode::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSamplerYcbcrConversionCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SamplerYcbcrConversionCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub format: Format,
    pub ycbcr_model: SamplerYcbcrModelConversion,
    pub ycbcr_range: SamplerYcbcrRange,
    pub components: ComponentMapping,
    pub x_chroma_offset: ChromaLocation,
    pub y_chroma_offset: ChromaLocation,
    pub chroma_filter: Filter,
    pub force_explicit_reconstruction: Bool32,
}

impl Default for SamplerYcbcrConversionCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
            next: ptr::null(),
            format: Format::default(),
            ycbcr_model: SamplerYcbcrModelConversion::default(),
            ycbcr_range: SamplerYcbcrRange::default(),
            components: ComponentMapping::default(),
            x_chroma_offset: ChromaLocation::default(),
            y_chroma_offset: ChromaLocation::default(),
            chroma_filter: Filter::default(),
            force_explicit_reconstruction: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSamplerYcbcrConversionImageFormatProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SamplerYcbcrConversionImageFormatProperties {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub combined_image_sampler_descriptor_count: u32,
}

impl Default for SamplerYcbcrConversionImageFormatProperties {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
            next: ptr::null_mut(),
            combined_image_sampler_descriptor_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSamplerYcbcrConversionInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SamplerYcbcrConversionInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub conversion: SamplerYcbcrConversion,
}

impl Default for SamplerYcbcrConversionInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SAMPLER_YCBCR_CONVERSION_INFO,
            next: ptr::null(),
            conversion: SamplerYcbcrConversion::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub enable_y_degamma: Bool32,
    pub enable_cb_cr_degamma: Bool32,
}

impl Default for SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM,
            next: ptr::null_mut(),
            enable_y_degamma: Bool32::default(),
            enable_cb_cr_degamma: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSciSyncAttributesInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SciSyncAttributesInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub client_type: SciSyncClientTypeNV,
    pub primitive_type: SciSyncPrimitiveTypeNV,
}

impl Default for SciSyncAttributesInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SCI_SYNC_ATTRIBUTES_INFO_NV,
            next: ptr::null(),
            client_type: SciSyncClientTypeNV::default(),
            primitive_type: SciSyncPrimitiveTypeNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkScreenBufferFormatPropertiesQNX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ScreenBufferFormatPropertiesQNX {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub format: Format,
    pub external_format: u64,
    pub screen_usage: u64,
    pub format_features: FormatFeatureFlags,
    pub sampler_ycbcr_conversion_components: ComponentMapping,
    pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
    pub suggested_ycbcr_range: SamplerYcbcrRange,
    pub suggested_x_chroma_offset: ChromaLocation,
    pub suggested_y_chroma_offset: ChromaLocation,
}

impl Default for ScreenBufferFormatPropertiesQNX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SCREEN_BUFFER_FORMAT_PROPERTIES_QNX,
            next: ptr::null_mut(),
            format: Format::default(),
            external_format: u64::default(),
            screen_usage: u64::default(),
            format_features: FormatFeatureFlags::default(),
            sampler_ycbcr_conversion_components: ComponentMapping::default(),
            suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
            suggested_ycbcr_range: SamplerYcbcrRange::default(),
            suggested_x_chroma_offset: ChromaLocation::default(),
            suggested_y_chroma_offset: ChromaLocation::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkScreenBufferPropertiesQNX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ScreenBufferPropertiesQNX {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub allocation_size: DeviceSize,
    pub memory_type_bits: u32,
}

impl Default for ScreenBufferPropertiesQNX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SCREEN_BUFFER_PROPERTIES_QNX,
            next: ptr::null_mut(),
            allocation_size: DeviceSize::default(),
            memory_type_bits: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkScreenSurfaceCreateInfoQNX.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ScreenSurfaceCreateInfoQNX {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: ScreenSurfaceCreateFlagsQNX,
    pub context: *mut _screen_context,
    pub window: *mut _screen_window,
}

impl Default for ScreenSurfaceCreateInfoQNX {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SCREEN_SURFACE_CREATE_INFO_QNX,
            next: ptr::null(),
            flags: ScreenSurfaceCreateFlagsQNX::default(),
            context: ptr::null_mut(),
            window: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSemaphoreCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SemaphoreCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: SemaphoreCreateFlags,
}

impl Default for SemaphoreCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SEMAPHORE_CREATE_INFO,
            next: ptr::null(),
            flags: SemaphoreCreateFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSemaphoreGetFdInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SemaphoreGetFdInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
}

impl Default for SemaphoreGetFdInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SEMAPHORE_GET_FD_INFO_KHR,
            next: ptr::null(),
            semaphore: Semaphore::default(),
            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSemaphoreGetSciSyncInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SemaphoreGetSciSyncInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
}

impl Default for SemaphoreGetSciSyncInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SEMAPHORE_GET_SCI_SYNC_INFO_NV,
            next: ptr::null(),
            semaphore: Semaphore::default(),
            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSemaphoreGetWin32HandleInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SemaphoreGetWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
}

impl Default for SemaphoreGetWin32HandleInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR,
            next: ptr::null(),
            semaphore: Semaphore::default(),
            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSemaphoreGetZirconHandleInfoFUCHSIA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SemaphoreGetZirconHandleInfoFUCHSIA {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
}

impl Default for SemaphoreGetZirconHandleInfoFUCHSIA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA,
            next: ptr::null(),
            semaphore: Semaphore::default(),
            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSemaphoreSciSyncCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SemaphoreSciSyncCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub semaphore_pool: SemaphoreSciSyncPoolNV,
    pub fence: *const NvSciSyncFence,
}

impl Default for SemaphoreSciSyncCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SEMAPHORE_SCI_SYNC_CREATE_INFO_NV,
            next: ptr::null(),
            semaphore_pool: SemaphoreSciSyncPoolNV::default(),
            fence: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSemaphoreSciSyncPoolCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SemaphoreSciSyncPoolCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub handle: NvSciSyncObj,
}

impl Default for SemaphoreSciSyncPoolCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SEMAPHORE_SCI_SYNC_POOL_CREATE_INFO_NV,
            next: ptr::null(),
            handle: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSemaphoreSignalInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SemaphoreSignalInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub value: u64,
}

impl Default for SemaphoreSignalInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SEMAPHORE_SIGNAL_INFO,
            next: ptr::null(),
            semaphore: Semaphore::default(),
            value: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSemaphoreSubmitInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SemaphoreSubmitInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub value: u64,
    pub stage_mask: PipelineStageFlags2,
    pub device_index: u32,
}

impl Default for SemaphoreSubmitInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SEMAPHORE_SUBMIT_INFO,
            next: ptr::null(),
            semaphore: Semaphore::default(),
            value: u64::default(),
            stage_mask: PipelineStageFlags2::default(),
            device_index: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSemaphoreTypeCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SemaphoreTypeCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub semaphore_type: SemaphoreType,
    pub initial_value: u64,
}

impl Default for SemaphoreTypeCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SEMAPHORE_TYPE_CREATE_INFO,
            next: ptr::null(),
            semaphore_type: SemaphoreType::default(),
            initial_value: u64::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSemaphoreWaitInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SemaphoreWaitInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: SemaphoreWaitFlags,
    pub semaphore_count: u32,
    pub semaphores: *const Semaphore,
    pub values: *const u64,
}

impl Default for SemaphoreWaitInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SEMAPHORE_WAIT_INFO,
            next: ptr::null(),
            flags: SemaphoreWaitFlags::default(),
            semaphore_count: u32::default(),
            semaphores: ptr::null(),
            values: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSetDescriptorBufferOffsetsInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SetDescriptorBufferOffsetsInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub stage_flags: ShaderStageFlags,
    pub layout: PipelineLayout,
    pub first_set: u32,
    pub set_count: u32,
    pub buffer_indices: *const u32,
    pub offsets: *const DeviceSize,
}

impl Default for SetDescriptorBufferOffsetsInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT,
            next: ptr::null(),
            stage_flags: ShaderStageFlags::default(),
            layout: PipelineLayout::default(),
            first_set: u32::default(),
            set_count: u32::default(),
            buffer_indices: ptr::null(),
            offsets: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSetLatencyMarkerInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SetLatencyMarkerInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub present_id: u64,
    pub marker: LatencyMarkerNV,
}

impl Default for SetLatencyMarkerInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SET_LATENCY_MARKER_INFO_NV,
            next: ptr::null(),
            present_id: u64::default(),
            marker: LatencyMarkerNV::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSetPresentConfigNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SetPresentConfigNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub num_frames_per_batch: u32,
    pub present_config_feedback: u32,
}

impl Default for SetPresentConfigNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SET_PRESENT_CONFIG_NV,
            next: ptr::null(),
            num_frames_per_batch: u32::default(),
            present_config_feedback: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSetStateFlagsIndirectCommandNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct SetStateFlagsIndirectCommandNV {
    pub data: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkShaderCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ShaderCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: ShaderCreateFlagsEXT,
    pub stage: ShaderStageFlags,
    pub next_stage: ShaderStageFlags,
    pub code_type: ShaderCodeTypeEXT,
    pub code_size: usize,
    pub code: *const c_void,
    pub name: *const c_char,
    pub set_layout_count: u32,
    pub set_layouts: *const DescriptorSetLayout,
    pub push_constant_range_count: u32,
    pub push_constant_ranges: *const PushConstantRange,
    pub specialization_info: *const SpecializationInfo,
}

impl Default for ShaderCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SHADER_CREATE_INFO_EXT,
            next: ptr::null(),
            flags: ShaderCreateFlagsEXT::default(),
            stage: ShaderStageFlags::default(),
            next_stage: ShaderStageFlags::default(),
            code_type: ShaderCodeTypeEXT::default(),
            code_size: usize::default(),
            code: ptr::null(),
            name: ptr::null(),
            set_layout_count: u32::default(),
            set_layouts: ptr::null(),
            push_constant_range_count: u32::default(),
            push_constant_ranges: ptr::null(),
            specialization_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkShaderModuleCreateInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ShaderModuleCreateInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: ShaderModuleCreateFlags,
    pub code_size: usize,
    pub code: *const u32,
}

impl Default for ShaderModuleCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SHADER_MODULE_CREATE_INFO,
            next: ptr::null(),
            flags: ShaderModuleCreateFlags::default(),
            code_size: usize::default(),
            code: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkShaderModuleIdentifierEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ShaderModuleIdentifierEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub identifier_size: u32,
    pub identifier: ByteArray<MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT>,
}

impl Default for ShaderModuleIdentifierEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SHADER_MODULE_IDENTIFIER_EXT,
            next: ptr::null_mut(),
            identifier_size: u32::default(),
            identifier: ByteArray::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkShaderModuleValidationCacheCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ShaderModuleValidationCacheCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub validation_cache: ValidationCacheEXT,
}

impl Default for ShaderModuleValidationCacheCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT,
            next: ptr::null(),
            validation_cache: ValidationCacheEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkShaderResourceUsageAMD.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ShaderResourceUsageAMD {
    pub num_used_vgprs: u32,
    pub num_used_sgprs: u32,
    pub lds_size_per_local_work_group: u32,
    pub lds_usage_size_in_bytes: usize,
    pub scratch_mem_usage_in_bytes: usize,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkShaderStatisticsInfoAMD.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ShaderStatisticsInfoAMD {
    pub shader_stage_mask: ShaderStageFlags,
    pub resource_usage: ShaderResourceUsageAMD,
    pub num_physical_vgprs: u32,
    pub num_physical_sgprs: u32,
    pub num_available_vgprs: u32,
    pub num_available_sgprs: u32,
    pub compute_work_group_size: [u32; 3],
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkShadingRatePaletteNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ShadingRatePaletteNV {
    pub shading_rate_palette_entry_count: u32,
    pub shading_rate_palette_entries: *const ShadingRatePaletteEntryNV,
}

impl Default for ShadingRatePaletteNV {
    #[inline]
    fn default() -> Self {
        Self {
            shading_rate_palette_entry_count: u32::default(),
            shading_rate_palette_entries: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSharedPresentSurfaceCapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SharedPresentSurfaceCapabilitiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub shared_present_supported_usage_flags: ImageUsageFlags,
}

impl Default for SharedPresentSurfaceCapabilitiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR,
            next: ptr::null_mut(),
            shared_present_supported_usage_flags: ImageUsageFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSparseBufferMemoryBindInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SparseBufferMemoryBindInfo {
    pub buffer: Buffer,
    pub bind_count: u32,
    pub binds: *const SparseMemoryBind,
}

impl Default for SparseBufferMemoryBindInfo {
    #[inline]
    fn default() -> Self {
        Self {
            buffer: Buffer::default(),
            bind_count: u32::default(),
            binds: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSparseImageFormatProperties.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct SparseImageFormatProperties {
    pub aspect_mask: ImageAspectFlags,
    pub image_granularity: Extent3D,
    pub flags: SparseImageFormatFlags,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSparseImageFormatProperties2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SparseImageFormatProperties2 {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub properties: SparseImageFormatProperties,
}

impl Default for SparseImageFormatProperties2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SPARSE_IMAGE_FORMAT_PROPERTIES_2,
            next: ptr::null_mut(),
            properties: SparseImageFormatProperties::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSparseImageMemoryBind.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct SparseImageMemoryBind {
    pub subresource: ImageSubresource,
    pub offset: Offset3D,
    pub extent: Extent3D,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
    pub flags: SparseMemoryBindFlags,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSparseImageMemoryBindInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SparseImageMemoryBindInfo {
    pub image: Image,
    pub bind_count: u32,
    pub binds: *const SparseImageMemoryBind,
}

impl Default for SparseImageMemoryBindInfo {
    #[inline]
    fn default() -> Self {
        Self {
            image: Image::default(),
            bind_count: u32::default(),
            binds: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSparseImageMemoryRequirements.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct SparseImageMemoryRequirements {
    pub format_properties: SparseImageFormatProperties,
    pub image_mip_tail_first_lod: u32,
    pub image_mip_tail_size: DeviceSize,
    pub image_mip_tail_offset: DeviceSize,
    pub image_mip_tail_stride: DeviceSize,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSparseImageMemoryRequirements2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SparseImageMemoryRequirements2 {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub memory_requirements: SparseImageMemoryRequirements,
}

impl Default for SparseImageMemoryRequirements2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
            next: ptr::null_mut(),
            memory_requirements: SparseImageMemoryRequirements::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSparseImageOpaqueMemoryBindInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SparseImageOpaqueMemoryBindInfo {
    pub image: Image,
    pub bind_count: u32,
    pub binds: *const SparseMemoryBind,
}

impl Default for SparseImageOpaqueMemoryBindInfo {
    #[inline]
    fn default() -> Self {
        Self {
            image: Image::default(),
            bind_count: u32::default(),
            binds: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSparseMemoryBind.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct SparseMemoryBind {
    pub resource_offset: DeviceSize,
    pub size: DeviceSize,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
    pub flags: SparseMemoryBindFlags,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSpecializationInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SpecializationInfo {
    pub map_entry_count: u32,
    pub map_entries: *const SpecializationMapEntry,
    pub data_size: usize,
    pub data: *const c_void,
}

impl Default for SpecializationInfo {
    #[inline]
    fn default() -> Self {
        Self {
            map_entry_count: u32::default(),
            map_entries: ptr::null(),
            data_size: usize::default(),
            data: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSpecializationMapEntry.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct SpecializationMapEntry {
    pub constant_id: u32,
    pub offset: u32,
    pub size: usize,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkStencilOpState.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct StencilOpState {
    pub fail_op: StencilOp,
    pub pass_op: StencilOp,
    pub depth_fail_op: StencilOp,
    pub compare_op: CompareOp,
    pub compare_mask: u32,
    pub write_mask: u32,
    pub reference: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkStreamDescriptorSurfaceCreateInfoGGP.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct StreamDescriptorSurfaceCreateInfoGGP {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: StreamDescriptorSurfaceCreateFlagsGGP,
    pub stream_descriptor: GgpStreamDescriptor,
}

impl Default for StreamDescriptorSurfaceCreateInfoGGP {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP,
            next: ptr::null(),
            flags: StreamDescriptorSurfaceCreateFlagsGGP::default(),
            stream_descriptor: GgpStreamDescriptor::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkStridedDeviceAddressNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct StridedDeviceAddressNV {
    pub start_address: DeviceAddress,
    pub stride_in_bytes: DeviceSize,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkStridedDeviceAddressRegionKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct StridedDeviceAddressRegionKHR {
    pub device_address: DeviceAddress,
    pub stride: DeviceSize,
    pub size: DeviceSize,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubmitInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SubmitInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub wait_semaphore_count: u32,
    pub wait_semaphores: *const Semaphore,
    pub wait_dst_stage_mask: *const PipelineStageFlags,
    pub command_buffer_count: u32,
    pub command_buffers: *const CommandBuffer,
    pub signal_semaphore_count: u32,
    pub signal_semaphores: *const Semaphore,
}

impl Default for SubmitInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SUBMIT_INFO,
            next: ptr::null(),
            wait_semaphore_count: u32::default(),
            wait_semaphores: ptr::null(),
            wait_dst_stage_mask: ptr::null(),
            command_buffer_count: u32::default(),
            command_buffers: ptr::null(),
            signal_semaphore_count: u32::default(),
            signal_semaphores: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubmitInfo2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SubmitInfo2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: SubmitFlags,
    pub wait_semaphore_info_count: u32,
    pub wait_semaphore_infos: *const SemaphoreSubmitInfo,
    pub command_buffer_info_count: u32,
    pub command_buffer_infos: *const CommandBufferSubmitInfo,
    pub signal_semaphore_info_count: u32,
    pub signal_semaphore_infos: *const SemaphoreSubmitInfo,
}

impl Default for SubmitInfo2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SUBMIT_INFO_2,
            next: ptr::null(),
            flags: SubmitFlags::default(),
            wait_semaphore_info_count: u32::default(),
            wait_semaphore_infos: ptr::null(),
            command_buffer_info_count: u32::default(),
            command_buffer_infos: ptr::null(),
            signal_semaphore_info_count: u32::default(),
            signal_semaphore_infos: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubpassBeginInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SubpassBeginInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub contents: SubpassContents,
}

impl Default for SubpassBeginInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SUBPASS_BEGIN_INFO,
            next: ptr::null(),
            contents: SubpassContents::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubpassDependency.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct SubpassDependency {
    pub src_subpass: u32,
    pub dst_subpass: u32,
    pub src_stage_mask: PipelineStageFlags,
    pub dst_stage_mask: PipelineStageFlags,
    pub src_access_mask: AccessFlags,
    pub dst_access_mask: AccessFlags,
    pub dependency_flags: DependencyFlags,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubpassDependency2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SubpassDependency2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub src_subpass: u32,
    pub dst_subpass: u32,
    pub src_stage_mask: PipelineStageFlags,
    pub dst_stage_mask: PipelineStageFlags,
    pub src_access_mask: AccessFlags,
    pub dst_access_mask: AccessFlags,
    pub dependency_flags: DependencyFlags,
    pub view_offset: i32,
}

impl Default for SubpassDependency2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SUBPASS_DEPENDENCY_2,
            next: ptr::null(),
            src_subpass: u32::default(),
            dst_subpass: u32::default(),
            src_stage_mask: PipelineStageFlags::default(),
            dst_stage_mask: PipelineStageFlags::default(),
            src_access_mask: AccessFlags::default(),
            dst_access_mask: AccessFlags::default(),
            dependency_flags: DependencyFlags::default(),
            view_offset: i32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubpassDescription.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SubpassDescription {
    pub flags: SubpassDescriptionFlags,
    pub pipeline_bind_point: PipelineBindPoint,
    pub input_attachment_count: u32,
    pub input_attachments: *const AttachmentReference,
    pub color_attachment_count: u32,
    pub color_attachments: *const AttachmentReference,
    pub resolve_attachments: *const AttachmentReference,
    pub depth_stencil_attachment: *const AttachmentReference,
    pub preserve_attachment_count: u32,
    pub preserve_attachments: *const u32,
}

impl Default for SubpassDescription {
    #[inline]
    fn default() -> Self {
        Self {
            flags: SubpassDescriptionFlags::default(),
            pipeline_bind_point: PipelineBindPoint::default(),
            input_attachment_count: u32::default(),
            input_attachments: ptr::null(),
            color_attachment_count: u32::default(),
            color_attachments: ptr::null(),
            resolve_attachments: ptr::null(),
            depth_stencil_attachment: ptr::null(),
            preserve_attachment_count: u32::default(),
            preserve_attachments: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubpassDescription2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SubpassDescription2 {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: SubpassDescriptionFlags,
    pub pipeline_bind_point: PipelineBindPoint,
    pub view_mask: u32,
    pub input_attachment_count: u32,
    pub input_attachments: *const AttachmentReference2,
    pub color_attachment_count: u32,
    pub color_attachments: *const AttachmentReference2,
    pub resolve_attachments: *const AttachmentReference2,
    pub depth_stencil_attachment: *const AttachmentReference2,
    pub preserve_attachment_count: u32,
    pub preserve_attachments: *const u32,
}

impl Default for SubpassDescription2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SUBPASS_DESCRIPTION_2,
            next: ptr::null(),
            flags: SubpassDescriptionFlags::default(),
            pipeline_bind_point: PipelineBindPoint::default(),
            view_mask: u32::default(),
            input_attachment_count: u32::default(),
            input_attachments: ptr::null(),
            color_attachment_count: u32::default(),
            color_attachments: ptr::null(),
            resolve_attachments: ptr::null(),
            depth_stencil_attachment: ptr::null(),
            preserve_attachment_count: u32::default(),
            preserve_attachments: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubpassDescriptionDepthStencilResolve.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SubpassDescriptionDepthStencilResolve {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub depth_resolve_mode: ResolveModeFlags,
    pub stencil_resolve_mode: ResolveModeFlags,
    pub depth_stencil_resolve_attachment: *const AttachmentReference2,
}

impl Default for SubpassDescriptionDepthStencilResolve {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE,
            next: ptr::null(),
            depth_resolve_mode: ResolveModeFlags::default(),
            stencil_resolve_mode: ResolveModeFlags::default(),
            depth_stencil_resolve_attachment: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubpassEndInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SubpassEndInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
}

impl Default for SubpassEndInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SUBPASS_END_INFO,
            next: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubpassFragmentDensityMapOffsetEndInfoQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SubpassFragmentDensityMapOffsetEndInfoQCOM {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub fragment_density_offset_count: u32,
    pub fragment_density_offsets: *const Offset2D,
}

impl Default for SubpassFragmentDensityMapOffsetEndInfoQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM,
            next: ptr::null(),
            fragment_density_offset_count: u32::default(),
            fragment_density_offsets: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubpassResolvePerformanceQueryEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SubpassResolvePerformanceQueryEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub optimal: Bool32,
}

impl Default for SubpassResolvePerformanceQueryEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT,
            next: ptr::null_mut(),
            optimal: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubpassSampleLocationsEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct SubpassSampleLocationsEXT {
    pub subpass_index: u32,
    pub sample_locations_info: SampleLocationsInfoEXT,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubpassShadingPipelineCreateInfoHUAWEI.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SubpassShadingPipelineCreateInfoHUAWEI {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub render_pass: RenderPass,
    pub subpass: u32,
}

impl Default for SubpassShadingPipelineCreateInfoHUAWEI {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI,
            next: ptr::null_mut(),
            render_pass: RenderPass::default(),
            subpass: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubresourceHostMemcpySize.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SubresourceHostMemcpySize {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub size: DeviceSize,
}

impl Default for SubresourceHostMemcpySize {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SUBRESOURCE_HOST_MEMCPY_SIZE,
            next: ptr::null_mut(),
            size: DeviceSize::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubresourceLayout.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct SubresourceLayout {
    pub offset: DeviceSize,
    pub size: DeviceSize,
    pub row_pitch: DeviceSize,
    pub array_pitch: DeviceSize,
    pub depth_pitch: DeviceSize,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubresourceLayout2.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SubresourceLayout2 {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub subresource_layout: SubresourceLayout,
}

impl Default for SubresourceLayout2 {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SUBRESOURCE_LAYOUT_2,
            next: ptr::null_mut(),
            subresource_layout: SubresourceLayout::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSurfaceCapabilities2EXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SurfaceCapabilities2EXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub min_image_count: u32,
    pub max_image_count: u32,
    pub current_extent: Extent2D,
    pub min_image_extent: Extent2D,
    pub max_image_extent: Extent2D,
    pub max_image_array_layers: u32,
    pub supported_transforms: SurfaceTransformFlagsKHR,
    pub current_transform: SurfaceTransformFlagsKHR,
    pub supported_composite_alpha: CompositeAlphaFlagsKHR,
    pub supported_usage_flags: ImageUsageFlags,
    pub supported_surface_counters: SurfaceCounterFlagsEXT,
}

impl Default for SurfaceCapabilities2EXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SURFACE_CAPABILITIES_2_EXT,
            next: ptr::null_mut(),
            min_image_count: u32::default(),
            max_image_count: u32::default(),
            current_extent: Extent2D::default(),
            min_image_extent: Extent2D::default(),
            max_image_extent: Extent2D::default(),
            max_image_array_layers: u32::default(),
            supported_transforms: SurfaceTransformFlagsKHR::default(),
            current_transform: SurfaceTransformFlagsKHR::default(),
            supported_composite_alpha: CompositeAlphaFlagsKHR::default(),
            supported_usage_flags: ImageUsageFlags::default(),
            supported_surface_counters: SurfaceCounterFlagsEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSurfaceCapabilities2KHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SurfaceCapabilities2KHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub surface_capabilities: SurfaceCapabilitiesKHR,
}

impl Default for SurfaceCapabilities2KHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SURFACE_CAPABILITIES_2_KHR,
            next: ptr::null_mut(),
            surface_capabilities: SurfaceCapabilitiesKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSurfaceCapabilitiesFullScreenExclusiveEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SurfaceCapabilitiesFullScreenExclusiveEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub full_screen_exclusive_supported: Bool32,
}

impl Default for SurfaceCapabilitiesFullScreenExclusiveEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT,
            next: ptr::null_mut(),
            full_screen_exclusive_supported: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSurfaceCapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct SurfaceCapabilitiesKHR {
    pub min_image_count: u32,
    pub max_image_count: u32,
    pub current_extent: Extent2D,
    pub min_image_extent: Extent2D,
    pub max_image_extent: Extent2D,
    pub max_image_array_layers: u32,
    pub supported_transforms: SurfaceTransformFlagsKHR,
    pub current_transform: SurfaceTransformFlagsKHR,
    pub supported_composite_alpha: CompositeAlphaFlagsKHR,
    pub supported_usage_flags: ImageUsageFlags,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSurfaceCapabilitiesPresentBarrierNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SurfaceCapabilitiesPresentBarrierNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub present_barrier_supported: Bool32,
}

impl Default for SurfaceCapabilitiesPresentBarrierNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SURFACE_CAPABILITIES_PRESENT_BARRIER_NV,
            next: ptr::null_mut(),
            present_barrier_supported: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSurfaceFormat2KHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SurfaceFormat2KHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub surface_format: SurfaceFormatKHR,
}

impl Default for SurfaceFormat2KHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SURFACE_FORMAT_2_KHR,
            next: ptr::null_mut(),
            surface_format: SurfaceFormatKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSurfaceFormatKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct SurfaceFormatKHR {
    pub format: Format,
    pub color_space: ColorSpaceKHR,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSurfaceFullScreenExclusiveInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SurfaceFullScreenExclusiveInfoEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub full_screen_exclusive: FullScreenExclusiveEXT,
}

impl Default for SurfaceFullScreenExclusiveInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT,
            next: ptr::null_mut(),
            full_screen_exclusive: FullScreenExclusiveEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSurfaceFullScreenExclusiveWin32InfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SurfaceFullScreenExclusiveWin32InfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub hmonitor: HMONITOR,
}

impl Default for SurfaceFullScreenExclusiveWin32InfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT,
            next: ptr::null(),
            hmonitor: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSurfacePresentModeCompatibilityEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SurfacePresentModeCompatibilityEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub present_mode_count: u32,
    pub present_modes: *mut PresentModeKHR,
}

impl Default for SurfacePresentModeCompatibilityEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SURFACE_PRESENT_MODE_COMPATIBILITY_EXT,
            next: ptr::null_mut(),
            present_mode_count: u32::default(),
            present_modes: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSurfacePresentModeEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SurfacePresentModeEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub present_mode: PresentModeKHR,
}

impl Default for SurfacePresentModeEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SURFACE_PRESENT_MODE_EXT,
            next: ptr::null_mut(),
            present_mode: PresentModeKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSurfacePresentScalingCapabilitiesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SurfacePresentScalingCapabilitiesEXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub supported_present_scaling: PresentScalingFlagsEXT,
    pub supported_present_gravity_x: PresentGravityFlagsEXT,
    pub supported_present_gravity_y: PresentGravityFlagsEXT,
    pub min_scaled_image_extent: Extent2D,
    pub max_scaled_image_extent: Extent2D,
}

impl Default for SurfacePresentScalingCapabilitiesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SURFACE_PRESENT_SCALING_CAPABILITIES_EXT,
            next: ptr::null_mut(),
            supported_present_scaling: PresentScalingFlagsEXT::default(),
            supported_present_gravity_x: PresentGravityFlagsEXT::default(),
            supported_present_gravity_y: PresentGravityFlagsEXT::default(),
            min_scaled_image_extent: Extent2D::default(),
            max_scaled_image_extent: Extent2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSurfaceProtectedCapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SurfaceProtectedCapabilitiesKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub supports_protected: Bool32,
}

impl Default for SurfaceProtectedCapabilitiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SURFACE_PROTECTED_CAPABILITIES_KHR,
            next: ptr::null(),
            supports_protected: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSwapchainCounterCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SwapchainCounterCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub surface_counters: SurfaceCounterFlagsEXT,
}

impl Default for SwapchainCounterCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SWAPCHAIN_COUNTER_CREATE_INFO_EXT,
            next: ptr::null(),
            surface_counters: SurfaceCounterFlagsEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSwapchainCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SwapchainCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: SwapchainCreateFlagsKHR,
    pub surface: SurfaceKHR,
    pub min_image_count: u32,
    pub image_format: Format,
    pub image_color_space: ColorSpaceKHR,
    pub image_extent: Extent2D,
    pub image_array_layers: u32,
    pub image_usage: ImageUsageFlags,
    pub image_sharing_mode: SharingMode,
    pub queue_family_index_count: u32,
    pub queue_family_indices: *const u32,
    pub pre_transform: SurfaceTransformFlagsKHR,
    pub composite_alpha: CompositeAlphaFlagsKHR,
    pub present_mode: PresentModeKHR,
    pub clipped: Bool32,
    pub old_swapchain: SwapchainKHR,
}

impl Default for SwapchainCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SWAPCHAIN_CREATE_INFO_KHR,
            next: ptr::null(),
            flags: SwapchainCreateFlagsKHR::default(),
            surface: SurfaceKHR::default(),
            min_image_count: u32::default(),
            image_format: Format::default(),
            image_color_space: ColorSpaceKHR::default(),
            image_extent: Extent2D::default(),
            image_array_layers: u32::default(),
            image_usage: ImageUsageFlags::default(),
            image_sharing_mode: SharingMode::default(),
            queue_family_index_count: u32::default(),
            queue_family_indices: ptr::null(),
            pre_transform: SurfaceTransformFlagsKHR::default(),
            composite_alpha: CompositeAlphaFlagsKHR::default(),
            present_mode: PresentModeKHR::default(),
            clipped: Bool32::default(),
            old_swapchain: SwapchainKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSwapchainDisplayNativeHdrCreateInfoAMD.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SwapchainDisplayNativeHdrCreateInfoAMD {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub local_dimming_enable: Bool32,
}

impl Default for SwapchainDisplayNativeHdrCreateInfoAMD {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD,
            next: ptr::null(),
            local_dimming_enable: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSwapchainLatencyCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SwapchainLatencyCreateInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub latency_mode_enable: Bool32,
}

impl Default for SwapchainLatencyCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SWAPCHAIN_LATENCY_CREATE_INFO_NV,
            next: ptr::null(),
            latency_mode_enable: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSwapchainPresentBarrierCreateInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SwapchainPresentBarrierCreateInfoNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub present_barrier_enable: Bool32,
}

impl Default for SwapchainPresentBarrierCreateInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV,
            next: ptr::null_mut(),
            present_barrier_enable: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSwapchainPresentFenceInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SwapchainPresentFenceInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub swapchain_count: u32,
    pub fences: *const Fence,
}

impl Default for SwapchainPresentFenceInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SWAPCHAIN_PRESENT_FENCE_INFO_EXT,
            next: ptr::null(),
            swapchain_count: u32::default(),
            fences: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSwapchainPresentModeInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SwapchainPresentModeInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub swapchain_count: u32,
    pub present_modes: *const PresentModeKHR,
}

impl Default for SwapchainPresentModeInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SWAPCHAIN_PRESENT_MODE_INFO_EXT,
            next: ptr::null(),
            swapchain_count: u32::default(),
            present_modes: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSwapchainPresentModesCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SwapchainPresentModesCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub present_mode_count: u32,
    pub present_modes: *const PresentModeKHR,
}

impl Default for SwapchainPresentModesCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT,
            next: ptr::null(),
            present_mode_count: u32::default(),
            present_modes: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSwapchainPresentScalingCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SwapchainPresentScalingCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub scaling_behavior: PresentScalingFlagsEXT,
    pub present_gravity_x: PresentGravityFlagsEXT,
    pub present_gravity_y: PresentGravityFlagsEXT,
}

impl Default for SwapchainPresentScalingCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT,
            next: ptr::null(),
            scaling_behavior: PresentScalingFlagsEXT::default(),
            present_gravity_x: PresentGravityFlagsEXT::default(),
            present_gravity_y: PresentGravityFlagsEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSysmemColorSpaceFUCHSIA.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct SysmemColorSpaceFUCHSIA {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub color_space: u32,
}

impl Default for SysmemColorSpaceFUCHSIA {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::SYSMEM_COLOR_SPACE_FUCHSIA,
            next: ptr::null(),
            color_space: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkTextureLODGatherFormatPropertiesAMD.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct TextureLODGatherFormatPropertiesAMD {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub supports_texture_gather_lod_bias_amd: Bool32,
}

impl Default for TextureLODGatherFormatPropertiesAMD {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD,
            next: ptr::null_mut(),
            supports_texture_gather_lod_bias_amd: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkTilePropertiesQCOM.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct TilePropertiesQCOM {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub tile_size: Extent3D,
    pub apron_size: Extent2D,
    pub origin: Offset2D,
}

impl Default for TilePropertiesQCOM {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::TILE_PROPERTIES_QCOM,
            next: ptr::null_mut(),
            tile_size: Extent3D::default(),
            apron_size: Extent2D::default(),
            origin: Offset2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkTimelineSemaphoreSubmitInfo.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct TimelineSemaphoreSubmitInfo {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub wait_semaphore_value_count: u32,
    pub wait_semaphore_values: *const u64,
    pub signal_semaphore_value_count: u32,
    pub signal_semaphore_values: *const u64,
}

impl Default for TimelineSemaphoreSubmitInfo {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::TIMELINE_SEMAPHORE_SUBMIT_INFO,
            next: ptr::null(),
            wait_semaphore_value_count: u32::default(),
            wait_semaphore_values: ptr::null(),
            signal_semaphore_value_count: u32::default(),
            signal_semaphore_values: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkTraceRaysIndirectCommand2KHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct TraceRaysIndirectCommand2KHR {
    pub raygen_shader_record_address: DeviceAddress,
    pub raygen_shader_record_size: DeviceSize,
    pub miss_shader_binding_table_address: DeviceAddress,
    pub miss_shader_binding_table_size: DeviceSize,
    pub miss_shader_binding_table_stride: DeviceSize,
    pub hit_shader_binding_table_address: DeviceAddress,
    pub hit_shader_binding_table_size: DeviceSize,
    pub hit_shader_binding_table_stride: DeviceSize,
    pub callable_shader_binding_table_address: DeviceAddress,
    pub callable_shader_binding_table_size: DeviceSize,
    pub callable_shader_binding_table_stride: DeviceSize,
    pub width: u32,
    pub height: u32,
    pub depth: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkTraceRaysIndirectCommandKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct TraceRaysIndirectCommandKHR {
    pub width: u32,
    pub height: u32,
    pub depth: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkTransformMatrixKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq)]
pub struct TransformMatrixKHR {
    pub matrix: [[f32; 4]; 3],
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkValidationCacheCreateInfoEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ValidationCacheCreateInfoEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: ValidationCacheCreateFlagsEXT,
    pub initial_data_size: usize,
    pub initial_data: *const c_void,
}

impl Default for ValidationCacheCreateInfoEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VALIDATION_CACHE_CREATE_INFO_EXT,
            next: ptr::null(),
            flags: ValidationCacheCreateFlagsEXT::default(),
            initial_data_size: usize::default(),
            initial_data: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkValidationFeaturesEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ValidationFeaturesEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub enabled_validation_feature_count: u32,
    pub enabled_validation_features: *const ValidationFeatureEnableEXT,
    pub disabled_validation_feature_count: u32,
    pub disabled_validation_features: *const ValidationFeatureDisableEXT,
}

impl Default for ValidationFeaturesEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VALIDATION_FEATURES_EXT,
            next: ptr::null(),
            enabled_validation_feature_count: u32::default(),
            enabled_validation_features: ptr::null(),
            disabled_validation_feature_count: u32::default(),
            disabled_validation_features: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkValidationFlagsEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ValidationFlagsEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub disabled_validation_check_count: u32,
    pub disabled_validation_checks: *const ValidationCheckEXT,
}

impl Default for ValidationFlagsEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VALIDATION_FLAGS_EXT,
            next: ptr::null(),
            disabled_validation_check_count: u32::default(),
            disabled_validation_checks: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVertexInputAttributeDescription.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct VertexInputAttributeDescription {
    pub location: u32,
    pub binding: u32,
    pub format: Format,
    pub offset: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVertexInputAttributeDescription2EXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VertexInputAttributeDescription2EXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub location: u32,
    pub binding: u32,
    pub format: Format,
    pub offset: u32,
}

impl Default for VertexInputAttributeDescription2EXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT,
            next: ptr::null_mut(),
            location: u32::default(),
            binding: u32::default(),
            format: Format::default(),
            offset: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVertexInputBindingDescription.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct VertexInputBindingDescription {
    pub binding: u32,
    pub stride: u32,
    pub input_rate: VertexInputRate,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVertexInputBindingDescription2EXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VertexInputBindingDescription2EXT {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub binding: u32,
    pub stride: u32,
    pub input_rate: VertexInputRate,
    pub divisor: u32,
}

impl Default for VertexInputBindingDescription2EXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT,
            next: ptr::null_mut(),
            binding: u32::default(),
            stride: u32::default(),
            input_rate: VertexInputRate::default(),
            divisor: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVertexInputBindingDivisorDescription.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct VertexInputBindingDivisorDescription {
    pub binding: u32,
    pub divisor: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkViSurfaceCreateInfoNN.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct ViSurfaceCreateInfoNN {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: ViSurfaceCreateFlagsNN,
    pub window: *mut c_void,
}

impl Default for ViSurfaceCreateInfoNN {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VI_SURFACE_CREATE_INFO_NN,
            next: ptr::null(),
            flags: ViSurfaceCreateFlagsNN::default(),
            window: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoBeginCodingInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoBeginCodingInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: VideoBeginCodingFlagsKHR,
    pub video_session: VideoSessionKHR,
    pub video_session_parameters: VideoSessionParametersKHR,
    pub reference_slot_count: u32,
    pub reference_slots: *const VideoReferenceSlotInfoKHR,
}

impl Default for VideoBeginCodingInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_BEGIN_CODING_INFO_KHR,
            next: ptr::null(),
            flags: VideoBeginCodingFlagsKHR::default(),
            video_session: VideoSessionKHR::default(),
            video_session_parameters: VideoSessionParametersKHR::default(),
            reference_slot_count: u32::default(),
            reference_slots: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoCapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoCapabilitiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub flags: VideoCapabilityFlagsKHR,
    pub min_bitstream_buffer_offset_alignment: DeviceSize,
    pub min_bitstream_buffer_size_alignment: DeviceSize,
    pub picture_access_granularity: Extent2D,
    pub min_coded_extent: Extent2D,
    pub max_coded_extent: Extent2D,
    pub max_dpb_slots: u32,
    pub max_active_reference_pictures: u32,
    pub std_header_version: ExtensionProperties,
}

impl Default for VideoCapabilitiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_CAPABILITIES_KHR,
            next: ptr::null_mut(),
            flags: VideoCapabilityFlagsKHR::default(),
            min_bitstream_buffer_offset_alignment: DeviceSize::default(),
            min_bitstream_buffer_size_alignment: DeviceSize::default(),
            picture_access_granularity: Extent2D::default(),
            min_coded_extent: Extent2D::default(),
            max_coded_extent: Extent2D::default(),
            max_dpb_slots: u32::default(),
            max_active_reference_pictures: u32::default(),
            std_header_version: ExtensionProperties::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoCodingControlInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoCodingControlInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: VideoCodingControlFlagsKHR,
}

impl Default for VideoCodingControlInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_CODING_CONTROL_INFO_KHR,
            next: ptr::null(),
            flags: VideoCodingControlFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeAV1CapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeAV1CapabilitiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_level: video::StdVideoAV1Level,
}

impl Default for VideoDecodeAV1CapabilitiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_AV1_CAPABILITIES_KHR,
            next: ptr::null_mut(),
            max_level: video::StdVideoAV1Level::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeAV1DpbSlotInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeAV1DpbSlotInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_reference_info: *const video::StdVideoDecodeAV1ReferenceInfo,
}

impl Default for VideoDecodeAV1DpbSlotInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR,
            next: ptr::null(),
            std_reference_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeAV1InlineSessionParametersInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeAV1InlineSessionParametersInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_sequence_header: *const video::StdVideoAV1SequenceHeader,
}

impl Default for VideoDecodeAV1InlineSessionParametersInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR,
            next: ptr::null(),
            std_sequence_header: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeAV1PictureInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeAV1PictureInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_picture_info: *const video::StdVideoDecodeAV1PictureInfo,
    pub reference_name_slot_indices: [i32; MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR],
    pub frame_header_offset: u32,
    pub tile_count: u32,
    pub tile_offsets: *const u32,
    pub tile_sizes: *const u32,
}

impl Default for VideoDecodeAV1PictureInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_AV1_PICTURE_INFO_KHR,
            next: ptr::null(),
            std_picture_info: ptr::null(),
            reference_name_slot_indices: [i32::default(); MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR],
            frame_header_offset: u32::default(),
            tile_count: u32::default(),
            tile_offsets: ptr::null(),
            tile_sizes: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeAV1ProfileInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeAV1ProfileInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_profile: video::StdVideoAV1Profile,
    pub film_grain_support: Bool32,
}

impl Default for VideoDecodeAV1ProfileInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_AV1_PROFILE_INFO_KHR,
            next: ptr::null(),
            std_profile: video::StdVideoAV1Profile::default(),
            film_grain_support: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeAV1SessionParametersCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeAV1SessionParametersCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_sequence_header: *const video::StdVideoAV1SequenceHeader,
}

impl Default for VideoDecodeAV1SessionParametersCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR,
            next: ptr::null(),
            std_sequence_header: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeCapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeCapabilitiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub flags: VideoDecodeCapabilityFlagsKHR,
}

impl Default for VideoDecodeCapabilitiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_CAPABILITIES_KHR,
            next: ptr::null_mut(),
            flags: VideoDecodeCapabilityFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeH264CapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeH264CapabilitiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_level_idc: video::StdVideoH264LevelIdc,
    pub field_offset_granularity: Offset2D,
}

impl Default for VideoDecodeH264CapabilitiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_H264_CAPABILITIES_KHR,
            next: ptr::null_mut(),
            max_level_idc: video::StdVideoH264LevelIdc::default(),
            field_offset_granularity: Offset2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeH264DpbSlotInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeH264DpbSlotInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_reference_info: *const video::StdVideoDecodeH264ReferenceInfo,
}

impl Default for VideoDecodeH264DpbSlotInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR,
            next: ptr::null(),
            std_reference_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeH264InlineSessionParametersInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeH264InlineSessionParametersInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_sps: *const video::StdVideoH264SequenceParameterSet,
    pub std_pps: *const video::StdVideoH264PictureParameterSet,
}

impl Default for VideoDecodeH264InlineSessionParametersInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR,
            next: ptr::null(),
            std_sps: ptr::null(),
            std_pps: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeH264PictureInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeH264PictureInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_picture_info: *const video::StdVideoDecodeH264PictureInfo,
    pub slice_count: u32,
    pub slice_offsets: *const u32,
}

impl Default for VideoDecodeH264PictureInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_H264_PICTURE_INFO_KHR,
            next: ptr::null(),
            std_picture_info: ptr::null(),
            slice_count: u32::default(),
            slice_offsets: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeH264ProfileInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeH264ProfileInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_profile_idc: video::StdVideoH264ProfileIdc,
    pub picture_layout: VideoDecodeH264PictureLayoutFlagsKHR,
}

impl Default for VideoDecodeH264ProfileInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_H264_PROFILE_INFO_KHR,
            next: ptr::null(),
            std_profile_idc: video::StdVideoH264ProfileIdc::default(),
            picture_layout: VideoDecodeH264PictureLayoutFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeH264SessionParametersAddInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeH264SessionParametersAddInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_sps_count: u32,
    pub std_sp_ss: *const video::StdVideoH264SequenceParameterSet,
    pub std_pps_count: u32,
    pub std_pp_ss: *const video::StdVideoH264PictureParameterSet,
}

impl Default for VideoDecodeH264SessionParametersAddInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR,
            next: ptr::null(),
            std_sps_count: u32::default(),
            std_sp_ss: ptr::null(),
            std_pps_count: u32::default(),
            std_pp_ss: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeH264SessionParametersCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeH264SessionParametersCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub max_std_sps_count: u32,
    pub max_std_pps_count: u32,
    pub parameters_add_info: *const VideoDecodeH264SessionParametersAddInfoKHR,
}

impl Default for VideoDecodeH264SessionParametersCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR,
            next: ptr::null(),
            max_std_sps_count: u32::default(),
            max_std_pps_count: u32::default(),
            parameters_add_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeH265CapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeH265CapabilitiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_level_idc: video::StdVideoH265LevelIdc,
}

impl Default for VideoDecodeH265CapabilitiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_H265_CAPABILITIES_KHR,
            next: ptr::null_mut(),
            max_level_idc: video::StdVideoH265LevelIdc::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeH265DpbSlotInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeH265DpbSlotInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_reference_info: *const video::StdVideoDecodeH265ReferenceInfo,
}

impl Default for VideoDecodeH265DpbSlotInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR,
            next: ptr::null(),
            std_reference_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeH265InlineSessionParametersInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeH265InlineSessionParametersInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_vps: *const video::StdVideoH265VideoParameterSet,
    pub std_sps: *const video::StdVideoH265SequenceParameterSet,
    pub std_pps: *const video::StdVideoH265PictureParameterSet,
}

impl Default for VideoDecodeH265InlineSessionParametersInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR,
            next: ptr::null(),
            std_vps: ptr::null(),
            std_sps: ptr::null(),
            std_pps: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeH265PictureInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeH265PictureInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_picture_info: *const video::StdVideoDecodeH265PictureInfo,
    pub slice_segment_count: u32,
    pub slice_segment_offsets: *const u32,
}

impl Default for VideoDecodeH265PictureInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_H265_PICTURE_INFO_KHR,
            next: ptr::null(),
            std_picture_info: ptr::null(),
            slice_segment_count: u32::default(),
            slice_segment_offsets: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeH265ProfileInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeH265ProfileInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_profile_idc: video::StdVideoH265ProfileIdc,
}

impl Default for VideoDecodeH265ProfileInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_H265_PROFILE_INFO_KHR,
            next: ptr::null(),
            std_profile_idc: video::StdVideoH265ProfileIdc::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeH265SessionParametersAddInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeH265SessionParametersAddInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_vps_count: u32,
    pub std_vp_ss: *const video::StdVideoH265VideoParameterSet,
    pub std_sps_count: u32,
    pub std_sp_ss: *const video::StdVideoH265SequenceParameterSet,
    pub std_pps_count: u32,
    pub std_pp_ss: *const video::StdVideoH265PictureParameterSet,
}

impl Default for VideoDecodeH265SessionParametersAddInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR,
            next: ptr::null(),
            std_vps_count: u32::default(),
            std_vp_ss: ptr::null(),
            std_sps_count: u32::default(),
            std_sp_ss: ptr::null(),
            std_pps_count: u32::default(),
            std_pp_ss: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeH265SessionParametersCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeH265SessionParametersCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub max_std_vps_count: u32,
    pub max_std_sps_count: u32,
    pub max_std_pps_count: u32,
    pub parameters_add_info: *const VideoDecodeH265SessionParametersAddInfoKHR,
}

impl Default for VideoDecodeH265SessionParametersCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR,
            next: ptr::null(),
            max_std_vps_count: u32::default(),
            max_std_sps_count: u32::default(),
            max_std_pps_count: u32::default(),
            parameters_add_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: VideoDecodeFlagsKHR,
    pub src_buffer: Buffer,
    pub src_buffer_offset: DeviceSize,
    pub src_buffer_range: DeviceSize,
    pub dst_picture_resource: VideoPictureResourceInfoKHR,
    pub setup_reference_slot: *const VideoReferenceSlotInfoKHR,
    pub reference_slot_count: u32,
    pub reference_slots: *const VideoReferenceSlotInfoKHR,
}

impl Default for VideoDecodeInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_INFO_KHR,
            next: ptr::null(),
            flags: VideoDecodeFlagsKHR::default(),
            src_buffer: Buffer::default(),
            src_buffer_offset: DeviceSize::default(),
            src_buffer_range: DeviceSize::default(),
            dst_picture_resource: VideoPictureResourceInfoKHR::default(),
            setup_reference_slot: ptr::null(),
            reference_slot_count: u32::default(),
            reference_slots: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoDecodeUsageInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoDecodeUsageInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub video_usage_hints: VideoDecodeUsageFlagsKHR,
}

impl Default for VideoDecodeUsageInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_DECODE_USAGE_INFO_KHR,
            next: ptr::null(),
            video_usage_hints: VideoDecodeUsageFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeAV1CapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeAV1CapabilitiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub flags: VideoEncodeAV1CapabilityFlagsKHR,
    pub max_level: video::StdVideoAV1Level,
    pub coded_picture_alignment: Extent2D,
    pub max_tiles: Extent2D,
    pub min_tile_size: Extent2D,
    pub max_tile_size: Extent2D,
    pub superblock_sizes: VideoEncodeAV1SuperblockSizeFlagsKHR,
    pub max_single_reference_count: u32,
    pub single_reference_name_mask: u32,
    pub max_unidirectional_compound_reference_count: u32,
    pub max_unidirectional_compound_group1_reference_count: u32,
    pub unidirectional_compound_reference_name_mask: u32,
    pub max_bidirectional_compound_reference_count: u32,
    pub max_bidirectional_compound_group1_reference_count: u32,
    pub max_bidirectional_compound_group2_reference_count: u32,
    pub bidirectional_compound_reference_name_mask: u32,
    pub max_temporal_layer_count: u32,
    pub max_spatial_layer_count: u32,
    pub max_operating_points: u32,
    pub min_q_index: u32,
    pub max_q_index: u32,
    pub prefers_gop_remaining_frames: Bool32,
    pub requires_gop_remaining_frames: Bool32,
    pub std_syntax_flags: VideoEncodeAV1StdFlagsKHR,
}

impl Default for VideoEncodeAV1CapabilitiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_AV1_CAPABILITIES_KHR,
            next: ptr::null_mut(),
            flags: VideoEncodeAV1CapabilityFlagsKHR::default(),
            max_level: video::StdVideoAV1Level::default(),
            coded_picture_alignment: Extent2D::default(),
            max_tiles: Extent2D::default(),
            min_tile_size: Extent2D::default(),
            max_tile_size: Extent2D::default(),
            superblock_sizes: VideoEncodeAV1SuperblockSizeFlagsKHR::default(),
            max_single_reference_count: u32::default(),
            single_reference_name_mask: u32::default(),
            max_unidirectional_compound_reference_count: u32::default(),
            max_unidirectional_compound_group1_reference_count: u32::default(),
            unidirectional_compound_reference_name_mask: u32::default(),
            max_bidirectional_compound_reference_count: u32::default(),
            max_bidirectional_compound_group1_reference_count: u32::default(),
            max_bidirectional_compound_group2_reference_count: u32::default(),
            bidirectional_compound_reference_name_mask: u32::default(),
            max_temporal_layer_count: u32::default(),
            max_spatial_layer_count: u32::default(),
            max_operating_points: u32::default(),
            min_q_index: u32::default(),
            max_q_index: u32::default(),
            prefers_gop_remaining_frames: Bool32::default(),
            requires_gop_remaining_frames: Bool32::default(),
            std_syntax_flags: VideoEncodeAV1StdFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeAV1DpbSlotInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeAV1DpbSlotInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_reference_info: *const video::StdVideoEncodeAV1ReferenceInfo,
}

impl Default for VideoEncodeAV1DpbSlotInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR,
            next: ptr::null(),
            std_reference_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeAV1FrameSizeKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeAV1FrameSizeKHR {
    pub intra_frame_size: u32,
    pub predictive_frame_size: u32,
    pub bipredictive_frame_size: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeAV1GopRemainingFrameInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeAV1GopRemainingFrameInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub use_gop_remaining_frames: Bool32,
    pub gop_remaining_intra: u32,
    pub gop_remaining_predictive: u32,
    pub gop_remaining_bipredictive: u32,
}

impl Default for VideoEncodeAV1GopRemainingFrameInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR,
            next: ptr::null(),
            use_gop_remaining_frames: Bool32::default(),
            gop_remaining_intra: u32::default(),
            gop_remaining_predictive: u32::default(),
            gop_remaining_bipredictive: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeAV1PictureInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeAV1PictureInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub prediction_mode: VideoEncodeAV1PredictionModeKHR,
    pub rate_control_group: VideoEncodeAV1RateControlGroupKHR,
    pub constant_q_index: u32,
    pub std_picture_info: *const video::StdVideoEncodeAV1PictureInfo,
    pub reference_name_slot_indices: [i32; MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR],
    pub primary_reference_cdf_only: Bool32,
    pub generate_obu_extension_header: Bool32,
}

impl Default for VideoEncodeAV1PictureInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_AV1_PICTURE_INFO_KHR,
            next: ptr::null(),
            prediction_mode: VideoEncodeAV1PredictionModeKHR::default(),
            rate_control_group: VideoEncodeAV1RateControlGroupKHR::default(),
            constant_q_index: u32::default(),
            std_picture_info: ptr::null(),
            reference_name_slot_indices: [i32::default(); MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR],
            primary_reference_cdf_only: Bool32::default(),
            generate_obu_extension_header: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeAV1ProfileInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeAV1ProfileInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_profile: video::StdVideoAV1Profile,
}

impl Default for VideoEncodeAV1ProfileInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_AV1_PROFILE_INFO_KHR,
            next: ptr::null(),
            std_profile: video::StdVideoAV1Profile::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeAV1QIndexKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeAV1QIndexKHR {
    pub intra_q_index: u32,
    pub predictive_q_index: u32,
    pub bipredictive_q_index: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeAV1QualityLevelPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeAV1QualityLevelPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub preferred_rate_control_flags: VideoEncodeAV1RateControlFlagsKHR,
    pub preferred_gop_frame_count: u32,
    pub preferred_key_frame_period: u32,
    pub preferred_consecutive_bipredictive_frame_count: u32,
    pub preferred_temporal_layer_count: u32,
    pub preferred_constant_q_index: VideoEncodeAV1QIndexKHR,
    pub preferred_max_single_reference_count: u32,
    pub preferred_single_reference_name_mask: u32,
    pub preferred_max_unidirectional_compound_reference_count: u32,
    pub preferred_max_unidirectional_compound_group1_reference_count: u32,
    pub preferred_unidirectional_compound_reference_name_mask: u32,
    pub preferred_max_bidirectional_compound_reference_count: u32,
    pub preferred_max_bidirectional_compound_group1_reference_count: u32,
    pub preferred_max_bidirectional_compound_group2_reference_count: u32,
    pub preferred_bidirectional_compound_reference_name_mask: u32,
}

impl Default for VideoEncodeAV1QualityLevelPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR,
            next: ptr::null_mut(),
            preferred_rate_control_flags: VideoEncodeAV1RateControlFlagsKHR::default(),
            preferred_gop_frame_count: u32::default(),
            preferred_key_frame_period: u32::default(),
            preferred_consecutive_bipredictive_frame_count: u32::default(),
            preferred_temporal_layer_count: u32::default(),
            preferred_constant_q_index: VideoEncodeAV1QIndexKHR::default(),
            preferred_max_single_reference_count: u32::default(),
            preferred_single_reference_name_mask: u32::default(),
            preferred_max_unidirectional_compound_reference_count: u32::default(),
            preferred_max_unidirectional_compound_group1_reference_count: u32::default(),
            preferred_unidirectional_compound_reference_name_mask: u32::default(),
            preferred_max_bidirectional_compound_reference_count: u32::default(),
            preferred_max_bidirectional_compound_group1_reference_count: u32::default(),
            preferred_max_bidirectional_compound_group2_reference_count: u32::default(),
            preferred_bidirectional_compound_reference_name_mask: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeAV1QuantizationMapCapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeAV1QuantizationMapCapabilitiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub min_q_index_delta: i32,
    pub max_q_index_delta: i32,
}

impl Default for VideoEncodeAV1QuantizationMapCapabilitiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR,
            next: ptr::null_mut(),
            min_q_index_delta: i32::default(),
            max_q_index_delta: i32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeAV1RateControlInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeAV1RateControlInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: VideoEncodeAV1RateControlFlagsKHR,
    pub gop_frame_count: u32,
    pub key_frame_period: u32,
    pub consecutive_bipredictive_frame_count: u32,
    pub temporal_layer_count: u32,
}

impl Default for VideoEncodeAV1RateControlInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR,
            next: ptr::null(),
            flags: VideoEncodeAV1RateControlFlagsKHR::default(),
            gop_frame_count: u32::default(),
            key_frame_period: u32::default(),
            consecutive_bipredictive_frame_count: u32::default(),
            temporal_layer_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeAV1RateControlLayerInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeAV1RateControlLayerInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub use_min_q_index: Bool32,
    pub min_q_index: VideoEncodeAV1QIndexKHR,
    pub use_max_q_index: Bool32,
    pub max_q_index: VideoEncodeAV1QIndexKHR,
    pub use_max_frame_size: Bool32,
    pub max_frame_size: VideoEncodeAV1FrameSizeKHR,
}

impl Default for VideoEncodeAV1RateControlLayerInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR,
            next: ptr::null(),
            use_min_q_index: Bool32::default(),
            min_q_index: VideoEncodeAV1QIndexKHR::default(),
            use_max_q_index: Bool32::default(),
            max_q_index: VideoEncodeAV1QIndexKHR::default(),
            use_max_frame_size: Bool32::default(),
            max_frame_size: VideoEncodeAV1FrameSizeKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeAV1SessionCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeAV1SessionCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub use_max_level: Bool32,
    pub max_level: video::StdVideoAV1Level,
}

impl Default for VideoEncodeAV1SessionCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR,
            next: ptr::null(),
            use_max_level: Bool32::default(),
            max_level: video::StdVideoAV1Level::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeAV1SessionParametersCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeAV1SessionParametersCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_sequence_header: *const video::StdVideoAV1SequenceHeader,
    pub std_decoder_model_info: *const video::StdVideoEncodeAV1DecoderModelInfo,
    pub std_operating_point_count: u32,
    pub std_operating_points: *const video::StdVideoEncodeAV1OperatingPointInfo,
}

impl Default for VideoEncodeAV1SessionParametersCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR,
            next: ptr::null(),
            std_sequence_header: ptr::null(),
            std_decoder_model_info: ptr::null(),
            std_operating_point_count: u32::default(),
            std_operating_points: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeCapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeCapabilitiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub flags: VideoEncodeCapabilityFlagsKHR,
    pub rate_control_modes: VideoEncodeRateControlModeFlagsKHR,
    pub max_rate_control_layers: u32,
    pub max_bitrate: u64,
    pub max_quality_levels: u32,
    pub encode_input_picture_granularity: Extent2D,
    pub supported_encode_feedback_flags: VideoEncodeFeedbackFlagsKHR,
}

impl Default for VideoEncodeCapabilitiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_CAPABILITIES_KHR,
            next: ptr::null_mut(),
            flags: VideoEncodeCapabilityFlagsKHR::default(),
            rate_control_modes: VideoEncodeRateControlModeFlagsKHR::default(),
            max_rate_control_layers: u32::default(),
            max_bitrate: u64::default(),
            max_quality_levels: u32::default(),
            encode_input_picture_granularity: Extent2D::default(),
            supported_encode_feedback_flags: VideoEncodeFeedbackFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264CapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264CapabilitiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub flags: VideoEncodeH264CapabilityFlagsKHR,
    pub max_level_idc: video::StdVideoH264LevelIdc,
    pub max_slice_count: u32,
    pub max_p_picture_l0_reference_count: u32,
    pub max_b_picture_l0_reference_count: u32,
    pub max_l1_reference_count: u32,
    pub max_temporal_layer_count: u32,
    pub expect_dyadic_temporal_layer_pattern: Bool32,
    pub min_qp: i32,
    pub max_qp: i32,
    pub prefers_gop_remaining_frames: Bool32,
    pub requires_gop_remaining_frames: Bool32,
    pub std_syntax_flags: VideoEncodeH264StdFlagsKHR,
}

impl Default for VideoEncodeH264CapabilitiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H264_CAPABILITIES_KHR,
            next: ptr::null_mut(),
            flags: VideoEncodeH264CapabilityFlagsKHR::default(),
            max_level_idc: video::StdVideoH264LevelIdc::default(),
            max_slice_count: u32::default(),
            max_p_picture_l0_reference_count: u32::default(),
            max_b_picture_l0_reference_count: u32::default(),
            max_l1_reference_count: u32::default(),
            max_temporal_layer_count: u32::default(),
            expect_dyadic_temporal_layer_pattern: Bool32::default(),
            min_qp: i32::default(),
            max_qp: i32::default(),
            prefers_gop_remaining_frames: Bool32::default(),
            requires_gop_remaining_frames: Bool32::default(),
            std_syntax_flags: VideoEncodeH264StdFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264DpbSlotInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264DpbSlotInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_reference_info: *const video::StdVideoEncodeH264ReferenceInfo,
}

impl Default for VideoEncodeH264DpbSlotInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR,
            next: ptr::null(),
            std_reference_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264FrameSizeKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264FrameSizeKHR {
    pub frame_i_size: u32,
    pub frame_p_size: u32,
    pub frame_b_size: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264GopRemainingFrameInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264GopRemainingFrameInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub use_gop_remaining_frames: Bool32,
    pub gop_remaining_i: u32,
    pub gop_remaining_p: u32,
    pub gop_remaining_b: u32,
}

impl Default for VideoEncodeH264GopRemainingFrameInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR,
            next: ptr::null(),
            use_gop_remaining_frames: Bool32::default(),
            gop_remaining_i: u32::default(),
            gop_remaining_p: u32::default(),
            gop_remaining_b: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264NaluSliceInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264NaluSliceInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub constant_qp: i32,
    pub std_slice_header: *const video::StdVideoEncodeH264SliceHeader,
}

impl Default for VideoEncodeH264NaluSliceInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR,
            next: ptr::null(),
            constant_qp: i32::default(),
            std_slice_header: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264PictureInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264PictureInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub nalu_slice_entry_count: u32,
    pub nalu_slice_entries: *const VideoEncodeH264NaluSliceInfoKHR,
    pub std_picture_info: *const video::StdVideoEncodeH264PictureInfo,
    pub generate_prefix_nalu: Bool32,
}

impl Default for VideoEncodeH264PictureInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H264_PICTURE_INFO_KHR,
            next: ptr::null(),
            nalu_slice_entry_count: u32::default(),
            nalu_slice_entries: ptr::null(),
            std_picture_info: ptr::null(),
            generate_prefix_nalu: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264ProfileInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264ProfileInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_profile_idc: video::StdVideoH264ProfileIdc,
}

impl Default for VideoEncodeH264ProfileInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H264_PROFILE_INFO_KHR,
            next: ptr::null(),
            std_profile_idc: video::StdVideoH264ProfileIdc::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264QpKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264QpKHR {
    pub qp_i: i32,
    pub qp_p: i32,
    pub qp_b: i32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264QualityLevelPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264QualityLevelPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub preferred_rate_control_flags: VideoEncodeH264RateControlFlagsKHR,
    pub preferred_gop_frame_count: u32,
    pub preferred_idr_period: u32,
    pub preferred_consecutive_b_frame_count: u32,
    pub preferred_temporal_layer_count: u32,
    pub preferred_constant_qp: VideoEncodeH264QpKHR,
    pub preferred_max_l0_reference_count: u32,
    pub preferred_max_l1_reference_count: u32,
    pub preferred_std_entropy_coding_mode_flag: Bool32,
}

impl Default for VideoEncodeH264QualityLevelPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR,
            next: ptr::null_mut(),
            preferred_rate_control_flags: VideoEncodeH264RateControlFlagsKHR::default(),
            preferred_gop_frame_count: u32::default(),
            preferred_idr_period: u32::default(),
            preferred_consecutive_b_frame_count: u32::default(),
            preferred_temporal_layer_count: u32::default(),
            preferred_constant_qp: VideoEncodeH264QpKHR::default(),
            preferred_max_l0_reference_count: u32::default(),
            preferred_max_l1_reference_count: u32::default(),
            preferred_std_entropy_coding_mode_flag: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264QuantizationMapCapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264QuantizationMapCapabilitiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub min_qp_delta: i32,
    pub max_qp_delta: i32,
}

impl Default for VideoEncodeH264QuantizationMapCapabilitiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR,
            next: ptr::null_mut(),
            min_qp_delta: i32::default(),
            max_qp_delta: i32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264RateControlInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264RateControlInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: VideoEncodeH264RateControlFlagsKHR,
    pub gop_frame_count: u32,
    pub idr_period: u32,
    pub consecutive_b_frame_count: u32,
    pub temporal_layer_count: u32,
}

impl Default for VideoEncodeH264RateControlInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR,
            next: ptr::null(),
            flags: VideoEncodeH264RateControlFlagsKHR::default(),
            gop_frame_count: u32::default(),
            idr_period: u32::default(),
            consecutive_b_frame_count: u32::default(),
            temporal_layer_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264RateControlLayerInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264RateControlLayerInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub use_min_qp: Bool32,
    pub min_qp: VideoEncodeH264QpKHR,
    pub use_max_qp: Bool32,
    pub max_qp: VideoEncodeH264QpKHR,
    pub use_max_frame_size: Bool32,
    pub max_frame_size: VideoEncodeH264FrameSizeKHR,
}

impl Default for VideoEncodeH264RateControlLayerInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR,
            next: ptr::null(),
            use_min_qp: Bool32::default(),
            min_qp: VideoEncodeH264QpKHR::default(),
            use_max_qp: Bool32::default(),
            max_qp: VideoEncodeH264QpKHR::default(),
            use_max_frame_size: Bool32::default(),
            max_frame_size: VideoEncodeH264FrameSizeKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264SessionCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264SessionCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub use_max_level_idc: Bool32,
    pub max_level_idc: video::StdVideoH264LevelIdc,
}

impl Default for VideoEncodeH264SessionCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR,
            next: ptr::null(),
            use_max_level_idc: Bool32::default(),
            max_level_idc: video::StdVideoH264LevelIdc::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264SessionParametersAddInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264SessionParametersAddInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_sps_count: u32,
    pub std_sp_ss: *const video::StdVideoH264SequenceParameterSet,
    pub std_pps_count: u32,
    pub std_pp_ss: *const video::StdVideoH264PictureParameterSet,
}

impl Default for VideoEncodeH264SessionParametersAddInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR,
            next: ptr::null(),
            std_sps_count: u32::default(),
            std_sp_ss: ptr::null(),
            std_pps_count: u32::default(),
            std_pp_ss: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264SessionParametersCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264SessionParametersCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub max_std_sps_count: u32,
    pub max_std_pps_count: u32,
    pub parameters_add_info: *const VideoEncodeH264SessionParametersAddInfoKHR,
}

impl Default for VideoEncodeH264SessionParametersCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR,
            next: ptr::null(),
            max_std_sps_count: u32::default(),
            max_std_pps_count: u32::default(),
            parameters_add_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264SessionParametersFeedbackInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264SessionParametersFeedbackInfoKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub has_std_sps_overrides: Bool32,
    pub has_std_pps_overrides: Bool32,
}

impl Default for VideoEncodeH264SessionParametersFeedbackInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR,
            next: ptr::null_mut(),
            has_std_sps_overrides: Bool32::default(),
            has_std_pps_overrides: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH264SessionParametersGetInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH264SessionParametersGetInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub write_std_sps: Bool32,
    pub write_std_pps: Bool32,
    pub std_sps_id: u32,
    pub std_pps_id: u32,
}

impl Default for VideoEncodeH264SessionParametersGetInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR,
            next: ptr::null(),
            write_std_sps: Bool32::default(),
            write_std_pps: Bool32::default(),
            std_sps_id: u32::default(),
            std_pps_id: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265CapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265CapabilitiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub flags: VideoEncodeH265CapabilityFlagsKHR,
    pub max_level_idc: video::StdVideoH265LevelIdc,
    pub max_slice_segment_count: u32,
    pub max_tiles: Extent2D,
    pub ctb_sizes: VideoEncodeH265CtbSizeFlagsKHR,
    pub transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsKHR,
    pub max_p_picture_l0_reference_count: u32,
    pub max_b_picture_l0_reference_count: u32,
    pub max_l1_reference_count: u32,
    pub max_sub_layer_count: u32,
    pub expect_dyadic_temporal_sub_layer_pattern: Bool32,
    pub min_qp: i32,
    pub max_qp: i32,
    pub prefers_gop_remaining_frames: Bool32,
    pub requires_gop_remaining_frames: Bool32,
    pub std_syntax_flags: VideoEncodeH265StdFlagsKHR,
}

impl Default for VideoEncodeH265CapabilitiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H265_CAPABILITIES_KHR,
            next: ptr::null_mut(),
            flags: VideoEncodeH265CapabilityFlagsKHR::default(),
            max_level_idc: video::StdVideoH265LevelIdc::default(),
            max_slice_segment_count: u32::default(),
            max_tiles: Extent2D::default(),
            ctb_sizes: VideoEncodeH265CtbSizeFlagsKHR::default(),
            transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsKHR::default(),
            max_p_picture_l0_reference_count: u32::default(),
            max_b_picture_l0_reference_count: u32::default(),
            max_l1_reference_count: u32::default(),
            max_sub_layer_count: u32::default(),
            expect_dyadic_temporal_sub_layer_pattern: Bool32::default(),
            min_qp: i32::default(),
            max_qp: i32::default(),
            prefers_gop_remaining_frames: Bool32::default(),
            requires_gop_remaining_frames: Bool32::default(),
            std_syntax_flags: VideoEncodeH265StdFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265DpbSlotInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265DpbSlotInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_reference_info: *const video::StdVideoEncodeH265ReferenceInfo,
}

impl Default for VideoEncodeH265DpbSlotInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR,
            next: ptr::null(),
            std_reference_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265FrameSizeKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265FrameSizeKHR {
    pub frame_i_size: u32,
    pub frame_p_size: u32,
    pub frame_b_size: u32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265GopRemainingFrameInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265GopRemainingFrameInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub use_gop_remaining_frames: Bool32,
    pub gop_remaining_i: u32,
    pub gop_remaining_p: u32,
    pub gop_remaining_b: u32,
}

impl Default for VideoEncodeH265GopRemainingFrameInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR,
            next: ptr::null(),
            use_gop_remaining_frames: Bool32::default(),
            gop_remaining_i: u32::default(),
            gop_remaining_p: u32::default(),
            gop_remaining_b: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265NaluSliceSegmentInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265NaluSliceSegmentInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub constant_qp: i32,
    pub std_slice_segment_header: *const video::StdVideoEncodeH265SliceSegmentHeader,
}

impl Default for VideoEncodeH265NaluSliceSegmentInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR,
            next: ptr::null(),
            constant_qp: i32::default(),
            std_slice_segment_header: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265PictureInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265PictureInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub nalu_slice_segment_entry_count: u32,
    pub nalu_slice_segment_entries: *const VideoEncodeH265NaluSliceSegmentInfoKHR,
    pub std_picture_info: *const video::StdVideoEncodeH265PictureInfo,
}

impl Default for VideoEncodeH265PictureInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H265_PICTURE_INFO_KHR,
            next: ptr::null(),
            nalu_slice_segment_entry_count: u32::default(),
            nalu_slice_segment_entries: ptr::null(),
            std_picture_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265ProfileInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265ProfileInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_profile_idc: video::StdVideoH265ProfileIdc,
}

impl Default for VideoEncodeH265ProfileInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H265_PROFILE_INFO_KHR,
            next: ptr::null(),
            std_profile_idc: video::StdVideoH265ProfileIdc::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265QpKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265QpKHR {
    pub qp_i: i32,
    pub qp_p: i32,
    pub qp_b: i32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265QualityLevelPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265QualityLevelPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub preferred_rate_control_flags: VideoEncodeH265RateControlFlagsKHR,
    pub preferred_gop_frame_count: u32,
    pub preferred_idr_period: u32,
    pub preferred_consecutive_b_frame_count: u32,
    pub preferred_sub_layer_count: u32,
    pub preferred_constant_qp: VideoEncodeH265QpKHR,
    pub preferred_max_l0_reference_count: u32,
    pub preferred_max_l1_reference_count: u32,
}

impl Default for VideoEncodeH265QualityLevelPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR,
            next: ptr::null_mut(),
            preferred_rate_control_flags: VideoEncodeH265RateControlFlagsKHR::default(),
            preferred_gop_frame_count: u32::default(),
            preferred_idr_period: u32::default(),
            preferred_consecutive_b_frame_count: u32::default(),
            preferred_sub_layer_count: u32::default(),
            preferred_constant_qp: VideoEncodeH265QpKHR::default(),
            preferred_max_l0_reference_count: u32::default(),
            preferred_max_l1_reference_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265QuantizationMapCapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265QuantizationMapCapabilitiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub min_qp_delta: i32,
    pub max_qp_delta: i32,
}

impl Default for VideoEncodeH265QuantizationMapCapabilitiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR,
            next: ptr::null_mut(),
            min_qp_delta: i32::default(),
            max_qp_delta: i32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265RateControlInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265RateControlInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: VideoEncodeH265RateControlFlagsKHR,
    pub gop_frame_count: u32,
    pub idr_period: u32,
    pub consecutive_b_frame_count: u32,
    pub sub_layer_count: u32,
}

impl Default for VideoEncodeH265RateControlInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR,
            next: ptr::null(),
            flags: VideoEncodeH265RateControlFlagsKHR::default(),
            gop_frame_count: u32::default(),
            idr_period: u32::default(),
            consecutive_b_frame_count: u32::default(),
            sub_layer_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265RateControlLayerInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265RateControlLayerInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub use_min_qp: Bool32,
    pub min_qp: VideoEncodeH265QpKHR,
    pub use_max_qp: Bool32,
    pub max_qp: VideoEncodeH265QpKHR,
    pub use_max_frame_size: Bool32,
    pub max_frame_size: VideoEncodeH265FrameSizeKHR,
}

impl Default for VideoEncodeH265RateControlLayerInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR,
            next: ptr::null(),
            use_min_qp: Bool32::default(),
            min_qp: VideoEncodeH265QpKHR::default(),
            use_max_qp: Bool32::default(),
            max_qp: VideoEncodeH265QpKHR::default(),
            use_max_frame_size: Bool32::default(),
            max_frame_size: VideoEncodeH265FrameSizeKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265SessionCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub use_max_level_idc: Bool32,
    pub max_level_idc: video::StdVideoH265LevelIdc,
}

impl Default for VideoEncodeH265SessionCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR,
            next: ptr::null(),
            use_max_level_idc: Bool32::default(),
            max_level_idc: video::StdVideoH265LevelIdc::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionParametersAddInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265SessionParametersAddInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub std_vps_count: u32,
    pub std_vp_ss: *const video::StdVideoH265VideoParameterSet,
    pub std_sps_count: u32,
    pub std_sp_ss: *const video::StdVideoH265SequenceParameterSet,
    pub std_pps_count: u32,
    pub std_pp_ss: *const video::StdVideoH265PictureParameterSet,
}

impl Default for VideoEncodeH265SessionParametersAddInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR,
            next: ptr::null(),
            std_vps_count: u32::default(),
            std_vp_ss: ptr::null(),
            std_sps_count: u32::default(),
            std_sp_ss: ptr::null(),
            std_pps_count: u32::default(),
            std_pp_ss: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionParametersCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265SessionParametersCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub max_std_vps_count: u32,
    pub max_std_sps_count: u32,
    pub max_std_pps_count: u32,
    pub parameters_add_info: *const VideoEncodeH265SessionParametersAddInfoKHR,
}

impl Default for VideoEncodeH265SessionParametersCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR,
            next: ptr::null(),
            max_std_vps_count: u32::default(),
            max_std_sps_count: u32::default(),
            max_std_pps_count: u32::default(),
            parameters_add_info: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionParametersFeedbackInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265SessionParametersFeedbackInfoKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub has_std_vps_overrides: Bool32,
    pub has_std_sps_overrides: Bool32,
    pub has_std_pps_overrides: Bool32,
}

impl Default for VideoEncodeH265SessionParametersFeedbackInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR,
            next: ptr::null_mut(),
            has_std_vps_overrides: Bool32::default(),
            has_std_sps_overrides: Bool32::default(),
            has_std_pps_overrides: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionParametersGetInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeH265SessionParametersGetInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub write_std_vps: Bool32,
    pub write_std_sps: Bool32,
    pub write_std_pps: Bool32,
    pub std_vps_id: u32,
    pub std_sps_id: u32,
    pub std_pps_id: u32,
}

impl Default for VideoEncodeH265SessionParametersGetInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR,
            next: ptr::null(),
            write_std_vps: Bool32::default(),
            write_std_sps: Bool32::default(),
            write_std_pps: Bool32::default(),
            std_vps_id: u32::default(),
            std_sps_id: u32::default(),
            std_pps_id: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: VideoEncodeFlagsKHR,
    pub dst_buffer: Buffer,
    pub dst_buffer_offset: DeviceSize,
    pub dst_buffer_range: DeviceSize,
    pub src_picture_resource: VideoPictureResourceInfoKHR,
    pub setup_reference_slot: *const VideoReferenceSlotInfoKHR,
    pub reference_slot_count: u32,
    pub reference_slots: *const VideoReferenceSlotInfoKHR,
    pub preceding_externally_encoded_bytes: u32,
}

impl Default for VideoEncodeInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_INFO_KHR,
            next: ptr::null(),
            flags: VideoEncodeFlagsKHR::default(),
            dst_buffer: Buffer::default(),
            dst_buffer_offset: DeviceSize::default(),
            dst_buffer_range: DeviceSize::default(),
            src_picture_resource: VideoPictureResourceInfoKHR::default(),
            setup_reference_slot: ptr::null(),
            reference_slot_count: u32::default(),
            reference_slots: ptr::null(),
            preceding_externally_encoded_bytes: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeQualityLevelInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeQualityLevelInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub quality_level: u32,
}

impl Default for VideoEncodeQualityLevelInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR,
            next: ptr::null(),
            quality_level: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeQualityLevelPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeQualityLevelPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub preferred_rate_control_mode: VideoEncodeRateControlModeFlagsKHR,
    pub preferred_rate_control_layer_count: u32,
}

impl Default for VideoEncodeQualityLevelPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR,
            next: ptr::null_mut(),
            preferred_rate_control_mode: VideoEncodeRateControlModeFlagsKHR::default(),
            preferred_rate_control_layer_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeQuantizationMapCapabilitiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeQuantizationMapCapabilitiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub max_quantization_map_extent: Extent2D,
}

impl Default for VideoEncodeQuantizationMapCapabilitiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR,
            next: ptr::null_mut(),
            max_quantization_map_extent: Extent2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeQuantizationMapInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeQuantizationMapInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub quantization_map: ImageView,
    pub quantization_map_extent: Extent2D,
}

impl Default for VideoEncodeQuantizationMapInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR,
            next: ptr::null(),
            quantization_map: ImageView::default(),
            quantization_map_extent: Extent2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeQuantizationMapSessionParametersCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub quantization_map_texel_size: Extent2D,
}

impl Default for VideoEncodeQuantizationMapSessionParametersCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR,
            next: ptr::null(),
            quantization_map_texel_size: Extent2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeRateControlInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeRateControlInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: VideoEncodeRateControlFlagsKHR,
    pub rate_control_mode: VideoEncodeRateControlModeFlagsKHR,
    pub layer_count: u32,
    pub layers: *const VideoEncodeRateControlLayerInfoKHR,
    pub virtual_buffer_size_in_ms: u32,
    pub initial_virtual_buffer_size_in_ms: u32,
}

impl Default for VideoEncodeRateControlInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR,
            next: ptr::null(),
            flags: VideoEncodeRateControlFlagsKHR::default(),
            rate_control_mode: VideoEncodeRateControlModeFlagsKHR::default(),
            layer_count: u32::default(),
            layers: ptr::null(),
            virtual_buffer_size_in_ms: u32::default(),
            initial_virtual_buffer_size_in_ms: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeRateControlLayerInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeRateControlLayerInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub average_bitrate: u64,
    pub max_bitrate: u64,
    pub frame_rate_numerator: u32,
    pub frame_rate_denominator: u32,
}

impl Default for VideoEncodeRateControlLayerInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR,
            next: ptr::null(),
            average_bitrate: u64::default(),
            max_bitrate: u64::default(),
            frame_rate_numerator: u32::default(),
            frame_rate_denominator: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeSessionParametersFeedbackInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeSessionParametersFeedbackInfoKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub has_overrides: Bool32,
}

impl Default for VideoEncodeSessionParametersFeedbackInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR,
            next: ptr::null_mut(),
            has_overrides: Bool32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeSessionParametersGetInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeSessionParametersGetInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub video_session_parameters: VideoSessionParametersKHR,
}

impl Default for VideoEncodeSessionParametersGetInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR,
            next: ptr::null(),
            video_session_parameters: VideoSessionParametersKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEncodeUsageInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEncodeUsageInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub video_usage_hints: VideoEncodeUsageFlagsKHR,
    pub video_content_hints: VideoEncodeContentFlagsKHR,
    pub tuning_mode: VideoEncodeTuningModeKHR,
}

impl Default for VideoEncodeUsageInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_ENCODE_USAGE_INFO_KHR,
            next: ptr::null(),
            video_usage_hints: VideoEncodeUsageFlagsKHR::default(),
            video_content_hints: VideoEncodeContentFlagsKHR::default(),
            tuning_mode: VideoEncodeTuningModeKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoEndCodingInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoEndCodingInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: VideoEndCodingFlagsKHR,
}

impl Default for VideoEndCodingInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_END_CODING_INFO_KHR,
            next: ptr::null(),
            flags: VideoEndCodingFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoFormatAV1QuantizationMapPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoFormatAV1QuantizationMapPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub compatible_superblock_sizes: VideoEncodeAV1SuperblockSizeFlagsKHR,
}

impl Default for VideoFormatAV1QuantizationMapPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR,
            next: ptr::null_mut(),
            compatible_superblock_sizes: VideoEncodeAV1SuperblockSizeFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoFormatH265QuantizationMapPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoFormatH265QuantizationMapPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub compatible_ctb_sizes: VideoEncodeH265CtbSizeFlagsKHR,
}

impl Default for VideoFormatH265QuantizationMapPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR,
            next: ptr::null_mut(),
            compatible_ctb_sizes: VideoEncodeH265CtbSizeFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoFormatPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoFormatPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub format: Format,
    pub component_mapping: ComponentMapping,
    pub image_create_flags: ImageCreateFlags,
    pub image_type: ImageType,
    pub image_tiling: ImageTiling,
    pub image_usage_flags: ImageUsageFlags,
}

impl Default for VideoFormatPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_FORMAT_PROPERTIES_KHR,
            next: ptr::null_mut(),
            format: Format::default(),
            component_mapping: ComponentMapping::default(),
            image_create_flags: ImageCreateFlags::default(),
            image_type: ImageType::default(),
            image_tiling: ImageTiling::default(),
            image_usage_flags: ImageUsageFlags::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoFormatQuantizationMapPropertiesKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoFormatQuantizationMapPropertiesKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub quantization_map_texel_size: Extent2D,
}

impl Default for VideoFormatQuantizationMapPropertiesKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR,
            next: ptr::null_mut(),
            quantization_map_texel_size: Extent2D::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoInlineQueryInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoInlineQueryInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub query_pool: QueryPool,
    pub first_query: u32,
    pub query_count: u32,
}

impl Default for VideoInlineQueryInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_INLINE_QUERY_INFO_KHR,
            next: ptr::null(),
            query_pool: QueryPool::default(),
            first_query: u32::default(),
            query_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoPictureResourceInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoPictureResourceInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub coded_offset: Offset2D,
    pub coded_extent: Extent2D,
    pub base_array_layer: u32,
    pub image_view_binding: ImageView,
}

impl Default for VideoPictureResourceInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_PICTURE_RESOURCE_INFO_KHR,
            next: ptr::null(),
            coded_offset: Offset2D::default(),
            coded_extent: Extent2D::default(),
            base_array_layer: u32::default(),
            image_view_binding: ImageView::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoProfileInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoProfileInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub video_codec_operation: VideoCodecOperationFlagsKHR,
    pub chroma_subsampling: VideoChromaSubsamplingFlagsKHR,
    pub luma_bit_depth: VideoComponentBitDepthFlagsKHR,
    pub chroma_bit_depth: VideoComponentBitDepthFlagsKHR,
}

impl Default for VideoProfileInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_PROFILE_INFO_KHR,
            next: ptr::null(),
            video_codec_operation: VideoCodecOperationFlagsKHR::default(),
            chroma_subsampling: VideoChromaSubsamplingFlagsKHR::default(),
            luma_bit_depth: VideoComponentBitDepthFlagsKHR::default(),
            chroma_bit_depth: VideoComponentBitDepthFlagsKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoProfileListInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoProfileListInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub profile_count: u32,
    pub profiles: *const VideoProfileInfoKHR,
}

impl Default for VideoProfileListInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_PROFILE_LIST_INFO_KHR,
            next: ptr::null(),
            profile_count: u32::default(),
            profiles: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoReferenceSlotInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoReferenceSlotInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub slot_index: i32,
    pub picture_resource: *const VideoPictureResourceInfoKHR,
}

impl Default for VideoReferenceSlotInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_REFERENCE_SLOT_INFO_KHR,
            next: ptr::null(),
            slot_index: i32::default(),
            picture_resource: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoSessionCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoSessionCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub queue_family_index: u32,
    pub flags: VideoSessionCreateFlagsKHR,
    pub video_profile: *const VideoProfileInfoKHR,
    pub picture_format: Format,
    pub max_coded_extent: Extent2D,
    pub reference_picture_format: Format,
    pub max_dpb_slots: u32,
    pub max_active_reference_pictures: u32,
    pub std_header_version: *const ExtensionProperties,
}

impl Default for VideoSessionCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_SESSION_CREATE_INFO_KHR,
            next: ptr::null(),
            queue_family_index: u32::default(),
            flags: VideoSessionCreateFlagsKHR::default(),
            video_profile: ptr::null(),
            picture_format: Format::default(),
            max_coded_extent: Extent2D::default(),
            reference_picture_format: Format::default(),
            max_dpb_slots: u32::default(),
            max_active_reference_pictures: u32::default(),
            std_header_version: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoSessionMemoryRequirementsKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoSessionMemoryRequirementsKHR {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub memory_bind_index: u32,
    pub memory_requirements: MemoryRequirements,
}

impl Default for VideoSessionMemoryRequirementsKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR,
            next: ptr::null_mut(),
            memory_bind_index: u32::default(),
            memory_requirements: MemoryRequirements::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoSessionParametersCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoSessionParametersCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: VideoSessionParametersCreateFlagsKHR,
    pub video_session_parameters_template: VideoSessionParametersKHR,
    pub video_session: VideoSessionKHR,
}

impl Default for VideoSessionParametersCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR,
            next: ptr::null(),
            flags: VideoSessionParametersCreateFlagsKHR::default(),
            video_session_parameters_template: VideoSessionParametersKHR::default(),
            video_session: VideoSessionKHR::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVideoSessionParametersUpdateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct VideoSessionParametersUpdateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub update_sequence_count: u32,
}

impl Default for VideoSessionParametersUpdateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR,
            next: ptr::null(),
            update_sequence_count: u32::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkViewport.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq)]
pub struct Viewport {
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    pub min_depth: f32,
    pub max_depth: f32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkViewportSwizzleNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, Eq, Hash, PartialEq)]
pub struct ViewportSwizzleNV {
    pub x: ViewportCoordinateSwizzleNV,
    pub y: ViewportCoordinateSwizzleNV,
    pub z: ViewportCoordinateSwizzleNV,
    pub w: ViewportCoordinateSwizzleNV,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkViewportWScalingNV.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq)]
pub struct ViewportWScalingNV {
    pub xcoeff: f32,
    pub ycoeff: f32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkWaylandSurfaceCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct WaylandSurfaceCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: WaylandSurfaceCreateFlagsKHR,
    pub display: *mut wl_display,
    pub surface: *mut wl_surface,
}

impl Default for WaylandSurfaceCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::WAYLAND_SURFACE_CREATE_INFO_KHR,
            next: ptr::null(),
            flags: WaylandSurfaceCreateFlagsKHR::default(),
            display: ptr::null_mut(),
            surface: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkWin32KeyedMutexAcquireReleaseInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct Win32KeyedMutexAcquireReleaseInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub acquire_count: u32,
    pub acquire_syncs: *const DeviceMemory,
    pub acquire_keys: *const u64,
    pub acquire_timeouts: *const u32,
    pub release_count: u32,
    pub release_syncs: *const DeviceMemory,
    pub release_keys: *const u64,
}

impl Default for Win32KeyedMutexAcquireReleaseInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR,
            next: ptr::null(),
            acquire_count: u32::default(),
            acquire_syncs: ptr::null(),
            acquire_keys: ptr::null(),
            acquire_timeouts: ptr::null(),
            release_count: u32::default(),
            release_syncs: ptr::null(),
            release_keys: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkWin32KeyedMutexAcquireReleaseInfoNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct Win32KeyedMutexAcquireReleaseInfoNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub acquire_count: u32,
    pub acquire_syncs: *const DeviceMemory,
    pub acquire_keys: *const u64,
    pub acquire_timeout_milliseconds: *const u32,
    pub release_count: u32,
    pub release_syncs: *const DeviceMemory,
    pub release_keys: *const u64,
}

impl Default for Win32KeyedMutexAcquireReleaseInfoNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV,
            next: ptr::null(),
            acquire_count: u32::default(),
            acquire_syncs: ptr::null(),
            acquire_keys: ptr::null(),
            acquire_timeout_milliseconds: ptr::null(),
            release_count: u32::default(),
            release_syncs: ptr::null(),
            release_keys: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkWin32SurfaceCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct Win32SurfaceCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: Win32SurfaceCreateFlagsKHR,
    pub hinstance: HINSTANCE,
    pub hwnd: HWND,
}

impl Default for Win32SurfaceCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::WIN32_SURFACE_CREATE_INFO_KHR,
            next: ptr::null(),
            flags: Win32SurfaceCreateFlagsKHR::default(),
            hinstance: ptr::null_mut(),
            hwnd: ptr::null_mut(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkWriteDescriptorSet.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct WriteDescriptorSet {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub dst_set: DescriptorSet,
    pub dst_binding: u32,
    pub dst_array_element: u32,
    pub descriptor_count: u32,
    pub descriptor_type: DescriptorType,
    pub image_info: *const DescriptorImageInfo,
    pub buffer_info: *const DescriptorBufferInfo,
    pub texel_buffer_view: *const BufferView,
}

impl Default for WriteDescriptorSet {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::WRITE_DESCRIPTOR_SET,
            next: ptr::null(),
            dst_set: DescriptorSet::default(),
            dst_binding: u32::default(),
            dst_array_element: u32::default(),
            descriptor_count: u32::default(),
            descriptor_type: DescriptorType::default(),
            image_info: ptr::null(),
            buffer_info: ptr::null(),
            texel_buffer_view: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkWriteDescriptorSetAccelerationStructureKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct WriteDescriptorSetAccelerationStructureKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub acceleration_structure_count: u32,
    pub acceleration_structures: *const AccelerationStructureKHR,
}

impl Default for WriteDescriptorSetAccelerationStructureKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,
            next: ptr::null(),
            acceleration_structure_count: u32::default(),
            acceleration_structures: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkWriteDescriptorSetAccelerationStructureNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct WriteDescriptorSetAccelerationStructureNV {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub acceleration_structure_count: u32,
    pub acceleration_structures: *const AccelerationStructureNV,
}

impl Default for WriteDescriptorSetAccelerationStructureNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV,
            next: ptr::null(),
            acceleration_structure_count: u32::default(),
            acceleration_structures: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkWriteDescriptorSetInlineUniformBlock.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct WriteDescriptorSetInlineUniformBlock {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub data_size: u32,
    pub data: *const c_void,
}

impl Default for WriteDescriptorSetInlineUniformBlock {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK,
            next: ptr::null(),
            data_size: u32::default(),
            data: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkWriteDescriptorSetPartitionedAccelerationStructureNV.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct WriteDescriptorSetPartitionedAccelerationStructureNV {
    pub s_type: StructureType,
    pub next: *mut c_void,
    pub acceleration_structure_count: u32,
    pub acceleration_structures: *const DeviceAddress,
}

impl Default for WriteDescriptorSetPartitionedAccelerationStructureNV {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV,
            next: ptr::null_mut(),
            acceleration_structure_count: u32::default(),
            acceleration_structures: ptr::null(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkWriteIndirectExecutionSetPipelineEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct WriteIndirectExecutionSetPipelineEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub index: u32,
    pub pipeline: Pipeline,
}

impl Default for WriteIndirectExecutionSetPipelineEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT,
            next: ptr::null(),
            index: u32::default(),
            pipeline: Pipeline::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkWriteIndirectExecutionSetShaderEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct WriteIndirectExecutionSetShaderEXT {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub index: u32,
    pub shader: ShaderEXT,
}

impl Default for WriteIndirectExecutionSetShaderEXT {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT,
            next: ptr::null(),
            index: u32::default(),
            shader: ShaderEXT::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkXYColorEXT.html>
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq)]
pub struct XYColorEXT {
    pub x: f32,
    pub y: f32,
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkXcbSurfaceCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct XcbSurfaceCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: XcbSurfaceCreateFlagsKHR,
    pub connection: *mut xcb_connection_t,
    pub window: xcb_window_t,
}

impl Default for XcbSurfaceCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::XCB_SURFACE_CREATE_INFO_KHR,
            next: ptr::null(),
            flags: XcbSurfaceCreateFlagsKHR::default(),
            connection: ptr::null_mut(),
            window: xcb_window_t::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkXlibSurfaceCreateInfoKHR.html>
#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct XlibSurfaceCreateInfoKHR {
    pub s_type: StructureType,
    pub next: *const c_void,
    pub flags: XlibSurfaceCreateFlagsKHR,
    pub dpy: *mut Display,
    pub window: Window,
}

impl Default for XlibSurfaceCreateInfoKHR {
    #[inline]
    fn default() -> Self {
        Self {
            s_type: StructureType::XLIB_SURFACE_CREATE_INFO_KHR,
            next: ptr::null(),
            flags: XlibSurfaceCreateFlagsKHR::default(),
            dpy: ptr::null_mut(),
            window: Window::default(),
        }
    }
}

/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAabbPositionsNV.html>
pub type AabbPositionsNV = AabbPositionsKHR;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAccelerationStructureInstanceNV.html>
pub type AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAttachmentDescription2KHR.html>
pub type AttachmentDescription2KHR = AttachmentDescription2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAttachmentDescriptionStencilLayoutKHR.html>
pub type AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAttachmentReference2KHR.html>
pub type AttachmentReference2KHR = AttachmentReference2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAttachmentReferenceStencilLayoutKHR.html>
pub type AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkAttachmentSampleCountInfoNV.html>
pub type AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindBufferMemoryDeviceGroupInfoKHR.html>
pub type BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindBufferMemoryInfoKHR.html>
pub type BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindDescriptorSetsInfoKHR.html>
pub type BindDescriptorSetsInfoKHR = BindDescriptorSetsInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindImageMemoryDeviceGroupInfoKHR.html>
pub type BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindImageMemoryInfoKHR.html>
pub type BindImageMemoryInfoKHR = BindImageMemoryInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindImagePlaneMemoryInfoKHR.html>
pub type BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBindMemoryStatusKHR.html>
pub type BindMemoryStatusKHR = BindMemoryStatus;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBlitImageInfo2KHR.html>
pub type BlitImageInfo2KHR = BlitImageInfo2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferCopy2KHR.html>
pub type BufferCopy2KHR = BufferCopy2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferDeviceAddressInfoEXT.html>
pub type BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferDeviceAddressInfoKHR.html>
pub type BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferImageCopy2KHR.html>
pub type BufferImageCopy2KHR = BufferImageCopy2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferMemoryBarrier2KHR.html>
pub type BufferMemoryBarrier2KHR = BufferMemoryBarrier2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferMemoryRequirementsInfo2KHR.html>
pub type BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferOpaqueCaptureAddressCreateInfoKHR.html>
pub type BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkBufferUsageFlags2CreateInfoKHR.html>
pub type BufferUsageFlags2CreateInfoKHR = BufferUsageFlags2CreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCalibratedTimestampInfoEXT.html>
pub type CalibratedTimestampInfoEXT = CalibratedTimestampInfoKHR;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCommandBufferInheritanceRenderingInfoKHR.html>
pub type CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCommandBufferSubmitInfoKHR.html>
pub type CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkConformanceVersionKHR.html>
pub type ConformanceVersionKHR = ConformanceVersion;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyBufferInfo2KHR.html>
pub type CopyBufferInfo2KHR = CopyBufferInfo2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyBufferToImageInfo2KHR.html>
pub type CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyImageInfo2KHR.html>
pub type CopyImageInfo2KHR = CopyImageInfo2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyImageToBufferInfo2KHR.html>
pub type CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyImageToImageInfoEXT.html>
pub type CopyImageToImageInfoEXT = CopyImageToImageInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyImageToMemoryInfoEXT.html>
pub type CopyImageToMemoryInfoEXT = CopyImageToMemoryInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkCopyMemoryToImageInfoEXT.html>
pub type CopyMemoryToImageInfoEXT = CopyMemoryToImageInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDependencyInfoKHR.html>
pub type DependencyInfoKHR = DependencyInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorPoolInlineUniformBlockCreateInfoEXT.html>
pub type DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorSetLayoutBindingFlagsCreateInfoEXT.html>
pub type DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorSetLayoutSupportKHR.html>
pub type DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorSetVariableDescriptorCountAllocateInfoEXT.html>
pub type DescriptorSetVariableDescriptorCountAllocateInfoEXT =
    DescriptorSetVariableDescriptorCountAllocateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorSetVariableDescriptorCountLayoutSupportEXT.html>
pub type DescriptorSetVariableDescriptorCountLayoutSupportEXT =
    DescriptorSetVariableDescriptorCountLayoutSupport;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateCreateInfoKHR.html>
pub type DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateEntryKHR.html>
pub type DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceBufferMemoryRequirementsKHR.html>
pub type DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceGroupBindSparseInfoKHR.html>
pub type DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceGroupCommandBufferBeginInfoKHR.html>
pub type DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceGroupDeviceCreateInfoKHR.html>
pub type DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceGroupRenderPassBeginInfoKHR.html>
pub type DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceGroupSubmitInfoKHR.html>
pub type DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceImageMemoryRequirementsKHR.html>
pub type DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceImageSubresourceInfoKHR.html>
pub type DeviceImageSubresourceInfoKHR = DeviceImageSubresourceInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceMemoryOpaqueCaptureAddressInfoKHR.html>
pub type DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDevicePrivateDataCreateInfoEXT.html>
pub type DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceQueueGlobalPriorityCreateInfoEXT.html>
pub type DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkDeviceQueueGlobalPriorityCreateInfoKHR.html>
pub type DeviceQueueGlobalPriorityCreateInfoKHR = DeviceQueueGlobalPriorityCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportFenceCreateInfoKHR.html>
pub type ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportMemoryAllocateInfoKHR.html>
pub type ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExportSemaphoreCreateInfoKHR.html>
pub type ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalBufferPropertiesKHR.html>
pub type ExternalBufferPropertiesKHR = ExternalBufferProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalFencePropertiesKHR.html>
pub type ExternalFencePropertiesKHR = ExternalFenceProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalImageFormatPropertiesKHR.html>
pub type ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalMemoryBufferCreateInfoKHR.html>
pub type ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalMemoryImageCreateInfoKHR.html>
pub type ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalMemoryPropertiesKHR.html>
pub type ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkExternalSemaphorePropertiesKHR.html>
pub type ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFormatProperties2KHR.html>
pub type FormatProperties2KHR = FormatProperties2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFormatProperties3KHR.html>
pub type FormatProperties3KHR = FormatProperties3;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFramebufferAttachmentImageInfoKHR.html>
pub type FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkFramebufferAttachmentsCreateInfoKHR.html>
pub type FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkHostImageCopyDevicePerformanceQueryEXT.html>
pub type HostImageCopyDevicePerformanceQueryEXT = HostImageCopyDevicePerformanceQuery;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkHostImageLayoutTransitionInfoEXT.html>
pub type HostImageLayoutTransitionInfoEXT = HostImageLayoutTransitionInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageBlit2KHR.html>
pub type ImageBlit2KHR = ImageBlit2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageCopy2KHR.html>
pub type ImageCopy2KHR = ImageCopy2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageFormatListCreateInfoKHR.html>
pub type ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageFormatProperties2KHR.html>
pub type ImageFormatProperties2KHR = ImageFormatProperties2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageMemoryBarrier2KHR.html>
pub type ImageMemoryBarrier2KHR = ImageMemoryBarrier2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageMemoryRequirementsInfo2KHR.html>
pub type ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImagePlaneMemoryRequirementsInfoKHR.html>
pub type ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageResolve2KHR.html>
pub type ImageResolve2KHR = ImageResolve2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageSparseMemoryRequirementsInfo2KHR.html>
pub type ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageStencilUsageCreateInfoEXT.html>
pub type ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageSubresource2EXT.html>
pub type ImageSubresource2EXT = ImageSubresource2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageSubresource2KHR.html>
pub type ImageSubresource2KHR = ImageSubresource2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageToMemoryCopyEXT.html>
pub type ImageToMemoryCopyEXT = ImageToMemoryCopy;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkImageViewUsageCreateInfoKHR.html>
pub type ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkInputAttachmentAspectReferenceKHR.html>
pub type InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryAllocateFlagsInfoKHR.html>
pub type MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryBarrier2KHR.html>
pub type MemoryBarrier2KHR = MemoryBarrier2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryDedicatedAllocateInfoKHR.html>
pub type MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryDedicatedRequirementsKHR.html>
pub type MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryMapInfoKHR.html>
pub type MemoryMapInfoKHR = MemoryMapInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryOpaqueCaptureAddressAllocateInfoKHR.html>
pub type MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryRequirements2KHR.html>
pub type MemoryRequirements2KHR = MemoryRequirements2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryToImageCopyEXT.html>
pub type MemoryToImageCopyEXT = MemoryToImageCopy;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMemoryUnmapInfoKHR.html>
pub type MemoryUnmapInfoKHR = MemoryUnmapInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMutableDescriptorTypeCreateInfoVALVE.html>
pub type MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkMutableDescriptorTypeListVALVE.html>
pub type MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevice16BitStorageFeaturesKHR.html>
pub type PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevice8BitStorageFeaturesKHR.html>
pub type PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceBufferAddressFeaturesEXT.html>
pub type PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceBufferDeviceAddressFeaturesKHR.html>
pub type PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceComputeShaderDerivativesFeaturesNV.html>
pub type PhysicalDeviceComputeShaderDerivativesFeaturesNV =
    PhysicalDeviceComputeShaderDerivativesFeaturesKHR;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthClampZeroOneFeaturesEXT.html>
pub type PhysicalDeviceDepthClampZeroOneFeaturesEXT = PhysicalDeviceDepthClampZeroOneFeaturesKHR;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthStencilResolvePropertiesKHR.html>
pub type PhysicalDeviceDepthStencilResolvePropertiesKHR =
    PhysicalDeviceDepthStencilResolveProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorIndexingFeaturesEXT.html>
pub type PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorIndexingPropertiesEXT.html>
pub type PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDriverPropertiesKHR.html>
pub type PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDynamicRenderingFeaturesKHR.html>
pub type PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR.html>
pub type PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR =
    PhysicalDeviceDynamicRenderingLocalReadFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalBufferInfoKHR.html>
pub type PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalFenceInfoKHR.html>
pub type PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalImageFormatInfoKHR.html>
pub type PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalSciBufFeaturesNV.html>
pub type PhysicalDeviceExternalSciBufFeaturesNV = PhysicalDeviceExternalMemorySciBufFeaturesNV;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalSemaphoreInfoKHR.html>
pub type PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFeatures2KHR.html>
pub type PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFloat16Int8FeaturesKHR.html>
pub type PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFloatControlsPropertiesKHR.html>
pub type PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV.html>
pub type PhysicalDeviceFragmentShaderBarycentricFeaturesNV =
    PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT.html>
pub type PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR.html>
pub type PhysicalDeviceGlobalPriorityQueryFeaturesKHR = PhysicalDeviceGlobalPriorityQueryFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceGroupPropertiesKHR.html>
pub type PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceHostImageCopyFeaturesEXT.html>
pub type PhysicalDeviceHostImageCopyFeaturesEXT = PhysicalDeviceHostImageCopyFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceHostImageCopyPropertiesEXT.html>
pub type PhysicalDeviceHostImageCopyPropertiesEXT = PhysicalDeviceHostImageCopyProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceHostQueryResetFeaturesEXT.html>
pub type PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceIDPropertiesKHR.html>
pub type PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImageFormatInfo2KHR.html>
pub type PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImageRobustnessFeaturesEXT.html>
pub type PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceImagelessFramebufferFeaturesKHR.html>
pub type PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceIndexTypeUint8FeaturesEXT.html>
pub type PhysicalDeviceIndexTypeUint8FeaturesEXT = PhysicalDeviceIndexTypeUint8Features;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceIndexTypeUint8FeaturesKHR.html>
pub type PhysicalDeviceIndexTypeUint8FeaturesKHR = PhysicalDeviceIndexTypeUint8Features;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceInlineUniformBlockFeaturesEXT.html>
pub type PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceInlineUniformBlockPropertiesEXT.html>
pub type PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceLineRasterizationFeaturesEXT.html>
pub type PhysicalDeviceLineRasterizationFeaturesEXT = PhysicalDeviceLineRasterizationFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceLineRasterizationFeaturesKHR.html>
pub type PhysicalDeviceLineRasterizationFeaturesKHR = PhysicalDeviceLineRasterizationFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceLineRasterizationPropertiesEXT.html>
pub type PhysicalDeviceLineRasterizationPropertiesEXT = PhysicalDeviceLineRasterizationProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceLineRasterizationPropertiesKHR.html>
pub type PhysicalDeviceLineRasterizationPropertiesKHR = PhysicalDeviceLineRasterizationProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance3PropertiesKHR.html>
pub type PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance4FeaturesKHR.html>
pub type PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance4PropertiesKHR.html>
pub type PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance5FeaturesKHR.html>
pub type PhysicalDeviceMaintenance5FeaturesKHR = PhysicalDeviceMaintenance5Features;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance5PropertiesKHR.html>
pub type PhysicalDeviceMaintenance5PropertiesKHR = PhysicalDeviceMaintenance5Properties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance6FeaturesKHR.html>
pub type PhysicalDeviceMaintenance6FeaturesKHR = PhysicalDeviceMaintenance6Features;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance6PropertiesKHR.html>
pub type PhysicalDeviceMaintenance6PropertiesKHR = PhysicalDeviceMaintenance6Properties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryProperties2KHR.html>
pub type PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewFeaturesKHR.html>
pub type PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewPropertiesKHR.html>
pub type PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE.html>
pub type PhysicalDeviceMutableDescriptorTypeFeaturesVALVE =
    PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT.html>
pub type PhysicalDevicePipelineCreationCacheControlFeaturesEXT =
    PhysicalDevicePipelineCreationCacheControlFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineProtectedAccessFeaturesEXT.html>
pub type PhysicalDevicePipelineProtectedAccessFeaturesEXT =
    PhysicalDevicePipelineProtectedAccessFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineRobustnessFeaturesEXT.html>
pub type PhysicalDevicePipelineRobustnessFeaturesEXT = PhysicalDevicePipelineRobustnessFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineRobustnessPropertiesEXT.html>
pub type PhysicalDevicePipelineRobustnessPropertiesEXT = PhysicalDevicePipelineRobustnessProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePointClippingPropertiesKHR.html>
pub type PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePrivateDataFeaturesEXT.html>
pub type PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceProperties2KHR.html>
pub type PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDevicePushDescriptorPropertiesKHR.html>
pub type PhysicalDevicePushDescriptorPropertiesKHR = PhysicalDevicePushDescriptorProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.html>
pub type PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM =
    PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT.html>
pub type PhysicalDeviceSamplerFilterMinmaxPropertiesEXT =
    PhysicalDeviceSamplerFilterMinmaxProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR.html>
pub type PhysicalDeviceSamplerYcbcrConversionFeaturesKHR =
    PhysicalDeviceSamplerYcbcrConversionFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceScalarBlockLayoutFeaturesEXT.html>
pub type PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR.html>
pub type PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR =
    PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAtomicInt64FeaturesKHR.html>
pub type PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.html>
pub type PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT =
    PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderDrawParameterFeatures.html>
pub type PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderExpectAssumeFeaturesKHR.html>
pub type PhysicalDeviceShaderExpectAssumeFeaturesKHR = PhysicalDeviceShaderExpectAssumeFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderFloat16Int8FeaturesKHR.html>
pub type PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderFloatControls2FeaturesKHR.html>
pub type PhysicalDeviceShaderFloatControls2FeaturesKHR = PhysicalDeviceShaderFloatControls2Features;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR.html>
pub type PhysicalDeviceShaderIntegerDotProductFeaturesKHR =
    PhysicalDeviceShaderIntegerDotProductFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR.html>
pub type PhysicalDeviceShaderIntegerDotProductPropertiesKHR =
    PhysicalDeviceShaderIntegerDotProductProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR.html>
pub type PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR =
    PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR.html>
pub type PhysicalDeviceShaderSubgroupRotateFeaturesKHR = PhysicalDeviceShaderSubgroupRotateFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR.html>
pub type PhysicalDeviceShaderTerminateInvocationFeaturesKHR =
    PhysicalDeviceShaderTerminateInvocationFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSparseImageFormatInfo2KHR.html>
pub type PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSubgroupSizeControlFeaturesEXT.html>
pub type PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSubgroupSizeControlPropertiesEXT.html>
pub type PhysicalDeviceSubgroupSizeControlPropertiesEXT =
    PhysicalDeviceSubgroupSizeControlProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceSynchronization2FeaturesKHR.html>
pub type PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT.html>
pub type PhysicalDeviceTexelBufferAlignmentPropertiesEXT =
    PhysicalDeviceTexelBufferAlignmentProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT.html>
pub type PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT =
    PhysicalDeviceTextureCompressionASTCHDRFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceTimelineSemaphoreFeaturesKHR.html>
pub type PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceTimelineSemaphorePropertiesKHR.html>
pub type PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceToolPropertiesEXT.html>
pub type PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR.html>
pub type PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR =
    PhysicalDeviceUniformBufferStandardLayoutFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVariablePointerFeatures.html>
pub type PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVariablePointerFeaturesKHR.html>
pub type PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVariablePointersFeaturesKHR.html>
pub type PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT.html>
pub type PhysicalDeviceVertexAttributeDivisorFeaturesEXT =
    PhysicalDeviceVertexAttributeDivisorFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR.html>
pub type PhysicalDeviceVertexAttributeDivisorFeaturesKHR =
    PhysicalDeviceVertexAttributeDivisorFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR.html>
pub type PhysicalDeviceVertexAttributeDivisorPropertiesKHR =
    PhysicalDeviceVertexAttributeDivisorProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkanMemoryModelFeaturesKHR.html>
pub type PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.html>
pub type PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR =
    PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineCreateFlags2CreateInfoKHR.html>
pub type PipelineCreateFlags2CreateInfoKHR = PipelineCreateFlags2CreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineCreationFeedbackCreateInfoEXT.html>
pub type PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineCreationFeedbackEXT.html>
pub type PipelineCreationFeedbackEXT = PipelineCreationFeedback;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineInfoEXT.html>
pub type PipelineInfoEXT = PipelineInfoKHR;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineRasterizationLineStateCreateInfoEXT.html>
pub type PipelineRasterizationLineStateCreateInfoEXT = PipelineRasterizationLineStateCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineRasterizationLineStateCreateInfoKHR.html>
pub type PipelineRasterizationLineStateCreateInfoKHR = PipelineRasterizationLineStateCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineRenderingCreateInfoKHR.html>
pub type PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineRobustnessCreateInfoEXT.html>
pub type PipelineRobustnessCreateInfoEXT = PipelineRobustnessCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.html>
pub type PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT =
    PipelineShaderStageRequiredSubgroupSizeCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineTessellationDomainOriginStateCreateInfoKHR.html>
pub type PipelineTessellationDomainOriginStateCreateInfoKHR =
    PipelineTessellationDomainOriginStateCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineVertexInputDivisorStateCreateInfoEXT.html>
pub type PipelineVertexInputDivisorStateCreateInfoEXT = PipelineVertexInputDivisorStateCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPipelineVertexInputDivisorStateCreateInfoKHR.html>
pub type PipelineVertexInputDivisorStateCreateInfoKHR = PipelineVertexInputDivisorStateCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPrivateDataSlotCreateInfoEXT.html>
pub type PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPushConstantsInfoKHR.html>
pub type PushConstantsInfoKHR = PushConstantsInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPushDescriptorSetInfoKHR.html>
pub type PushDescriptorSetInfoKHR = PushDescriptorSetInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkPushDescriptorSetWithTemplateInfoKHR.html>
pub type PushDescriptorSetWithTemplateInfoKHR = PushDescriptorSetWithTemplateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkQueryPoolCreateInfoINTEL.html>
pub type QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkQueueFamilyGlobalPriorityPropertiesEXT.html>
pub type QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkQueueFamilyGlobalPriorityPropertiesKHR.html>
pub type QueueFamilyGlobalPriorityPropertiesKHR = QueueFamilyGlobalPriorityProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkQueueFamilyProperties2KHR.html>
pub type QueueFamilyProperties2KHR = QueueFamilyProperties2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassAttachmentBeginInfoKHR.html>
pub type RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassCreateInfo2KHR.html>
pub type RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassInputAttachmentAspectCreateInfoKHR.html>
pub type RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderPassMultiviewCreateInfoKHR.html>
pub type RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderingAreaInfoKHR.html>
pub type RenderingAreaInfoKHR = RenderingAreaInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderingAttachmentInfoKHR.html>
pub type RenderingAttachmentInfoKHR = RenderingAttachmentInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderingAttachmentLocationInfoKHR.html>
pub type RenderingAttachmentLocationInfoKHR = RenderingAttachmentLocationInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderingInfoKHR.html>
pub type RenderingInfoKHR = RenderingInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkRenderingInputAttachmentIndexInfoKHR.html>
pub type RenderingInputAttachmentIndexInfoKHR = RenderingInputAttachmentIndexInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkResolveImageInfo2KHR.html>
pub type ResolveImageInfo2KHR = ResolveImageInfo2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSamplerReductionModeCreateInfoEXT.html>
pub type SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSamplerYcbcrConversionCreateInfoKHR.html>
pub type SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSamplerYcbcrConversionImageFormatPropertiesKHR.html>
pub type SamplerYcbcrConversionImageFormatPropertiesKHR =
    SamplerYcbcrConversionImageFormatProperties;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSamplerYcbcrConversionInfoKHR.html>
pub type SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSemaphoreSignalInfoKHR.html>
pub type SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSemaphoreSubmitInfoKHR.html>
pub type SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSemaphoreTypeCreateInfoKHR.html>
pub type SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSemaphoreWaitInfoKHR.html>
pub type SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkShaderRequiredSubgroupSizeCreateInfoEXT.html>
pub type ShaderRequiredSubgroupSizeCreateInfoEXT =
    PipelineShaderStageRequiredSubgroupSizeCreateInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSparseImageFormatProperties2KHR.html>
pub type SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSparseImageMemoryRequirements2KHR.html>
pub type SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubmitInfo2KHR.html>
pub type SubmitInfo2KHR = SubmitInfo2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubpassBeginInfoKHR.html>
pub type SubpassBeginInfoKHR = SubpassBeginInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubpassDependency2KHR.html>
pub type SubpassDependency2KHR = SubpassDependency2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubpassDescription2KHR.html>
pub type SubpassDescription2KHR = SubpassDescription2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubpassDescriptionDepthStencilResolveKHR.html>
pub type SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubpassEndInfoKHR.html>
pub type SubpassEndInfoKHR = SubpassEndInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubresourceHostMemcpySizeEXT.html>
pub type SubresourceHostMemcpySizeEXT = SubresourceHostMemcpySize;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubresourceLayout2EXT.html>
pub type SubresourceLayout2EXT = SubresourceLayout2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkSubresourceLayout2KHR.html>
pub type SubresourceLayout2KHR = SubresourceLayout2;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkTimelineSemaphoreSubmitInfoKHR.html>
pub type TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkTransformMatrixNV.html>
pub type TransformMatrixNV = TransformMatrixKHR;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVertexInputBindingDivisorDescriptionEXT.html>
pub type VertexInputBindingDivisorDescriptionEXT = VertexInputBindingDivisorDescription;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkVertexInputBindingDivisorDescriptionKHR.html>
pub type VertexInputBindingDivisorDescriptionKHR = VertexInputBindingDivisorDescription;
/// <https://www.khronos.org/registry/vulkan/specs/latest/man/html/VkWriteDescriptorSetInlineUniformBlockEXT.html>
pub type WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock;