vulkan/api/vulkan.api

// Copyright (c) 2015 The Khronos Group Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and/or associated documentation files (the
// "Materials"), to deal in the Materials without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Materials, and to
// permit persons to whom the Materials are furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Materials.
//
// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

import platform "platform.api"

///////////////
// Constants //
///////////////

// API version (major.minor.patch)
define VERSION_MAJOR 1
define VERSION_MINOR 1
define VERSION_PATCH 90

// API limits
define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256
define VK_UUID_SIZE                     16
define VK_MAX_EXTENSION_NAME_SIZE       256
define VK_MAX_DESCRIPTION_SIZE          256
define VK_MAX_MEMORY_TYPES              32
define VK_MAX_MEMORY_HEAPS              16    /// The maximum number of unique memory heaps, each of which supporting 1 or more memory types.
@vulkan1_1
define VK_MAX_DEVICE_GROUP_SIZE         32
@vulkan1_1
define VK_LUID_SIZE                     8
@vulkan1_1
define VK_QUEUE_FAMILY_EXTERNAL         -2
@extension("VK_EXT_queue_family_foreign")
define VK_QUEUE_FAMILY_FOREIGN_EXT      -3
@extension("VK_MAX_DRIVER_NAME_SIZE_KHR") // 197
define VK_MAX_DRIVER_NAME_SIZE_KHR      256
@extension("VK_MAX_DRIVER_NAME_SIZE_KHR") // 197
define VK_MAX_DRIVER_INFO_SIZE_KHR      256

// API keywords
define VK_TRUE        1
define VK_FALSE       0

// API keyword, but needs special handling by some templates
define NULL_HANDLE 0

// 1
@extension("VK_KHR_surface") define VK_KHR_SURFACE_SPEC_VERSION                 25
@extension("VK_KHR_surface") define VK_KHR_SURFACE_EXTENSION_NAME               "VK_KHR_surface"

// 2
@extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_SPEC_VERSION             70
@extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_EXTENSION_NAME           "VK_KHR_swapchain"

// 3
@extension("VK_KHR_display") define VK_KHR_DISPLAY_SPEC_VERSION                 21
@extension("VK_KHR_display") define VK_KHR_DISPLAY_EXTENSION_NAME               "VK_KHR_display"

// 4
@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION     9
@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME   "VK_KHR_display_swapchain"

// 5
@extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_SPEC_VERSION       6
@extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_NAME               "VK_KHR_xlib_surface"

// 6
@extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_SPEC_VERSION         6
@extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_NAME                 "VK_KHR_xcb_surface"

// 7
@extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
@extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_NAME         "VK_KHR_wayland_surface"

// 8
@extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_SPEC_VERSION         4
@extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_NAME                 "VK_KHR_mir_surface"

// 9
@extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6
@extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_NAME         "VK_KHR_android_surface"

// 10
@extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_SPEC_VERSION     6
@extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_NAME             "VK_KHR_win32_surface"

// 11
@extension("VK_ANDROID_native_buffer") define VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION     7
@extension("VK_ANDROID_native_buffer") define VK_ANDROID_NATIVE_BUFFER_NAME             "VK_ANDROID_native_buffer"

// 12
@extension("VK_EXT_debug_report") define VK_EXT_DEBUG_REPORT_SPEC_VERSION       9
@extension("VK_EXT_debug_report") define VK_EXT_DEBUG_REPORT_NAME               "VK_EXT_debug_report"

// 13
@extension("VK_NV_glsl_shader") define VK_NV_GLSL_SHADER_SPEC_VERSION           1
@extension("VK_NV_glsl_shader") define VK_NV_GLSL_SHADER_NAME                   "VK_NV_glsl_shader"

// 14
@extension("VK_EXT_depth_range_unrestricted") define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION   1
@extension("VK_EXT_depth_range_unrestricted") define VK_EXT_DEPTH_RANGE_UNRESTRICTED_NAME           "VK_EXT_depth_range_unrestricted"

// 15
@extension("VK_KHR_sampler_mirror_clamp_to_edge") define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION   1
@extension("VK_KHR_sampler_mirror_clamp_to_edge") define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_NAME           "VK_KHR_sampler_mirror_clamp_to_edge"

// 16
@extension("VK_IMG_filter_cubic") define VK_IMG_FILTER_CUBIC_SPEC_VERSION       1
@extension("VK_IMG_filter_cubic") define VK_IMG_FILTER_CUBIC_NAME               "VK_IMG_filter_cubic"

// 19
@extension("VK_AMD_rasterization_order") define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION   1
@extension("VK_AMD_rasterization_order") define VK_AMD_RASTERIZATION_ORDER_NAME           "VK_AMD_rasterization_order"

// 21
@extension("VK_AMD_shader_trinary_minmax") define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1
@extension("VK_AMD_shader_trinary_minmax") define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"

// 22
@extension("VK_AMD_shader_explicit_vertex_parameter") define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1
@extension("VK_AMD_shader_explicit_vertex_parameter") define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"

// 23
@extension("VK_EXT_debug_marker") define VK_EXT_DEBUG_MARKER_SPEC_VERSION       4
@extension("VK_EXT_debug_marker") define VK_EXT_DEBUG_MARKER_NAME               "VK_EXT_debug_marker"

// 26
@extension("VK_AMD_gcn_shader") define VK_AMD_GCN_SHADER_SPEC_VERSION 1
@extension("VK_AMD_gcn_shader") define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader"

// 27
@extension("VK_NV_dedicated_allocation") define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1
@extension("VK_NV_dedicated_allocation") define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"

// 28
@extension("VK_IMG_format_pvrtc") define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1
@extension("VK_IMG_format_pvrtc") define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"

// 29
@extension("VK_EXT_transform_feedback") define VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION 1
@extension("VK_EXT_transform_feedback") define VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME "VK_EXT_transform_feedback"

// 34
@extension("VK_AMD_draw_indirect_count") define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
@extension("VK_AMD_draw_indirect_count") define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"

// 36
@extension("VK_AMD_negative_viewport_height") define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1
@extension("VK_AMD_negative_viewport_height") define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height"

// 37
@extension("VK_AMD_gpu_shader_half_float") define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1
@extension("VK_AMD_gpu_shader_half_float") define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float"

// 38
@extension("VK_AMD_shader_ballot") define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1
@extension("VK_AMD_shader_ballot") define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot"

// 42
@extension("VK_AMD_texture_gather_bias_lod") define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1
@extension("VK_AMD_texture_gather_bias_lod") define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod"

// 43
@extension("VK_AMD_shader_info") define VK_AMD_SHADER_INFO_SPEC_VERSION 1
@extension("VK_AMD_shader_info") define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info"

// 47
@extension("VK_AMD_shader_image_load_store_lod") define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1
@extension("VK_AMD_shader_image_load_store_lod") define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod"

// 51
@extension("VK_NV_corner_sampled_image") define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2
@extension("VK_NV_corner_sampled_image") define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image"

// 54
@extension("VK_KHR_multiview") define VK_KHR_MULTIVIEW_SPEC_VERSION 1
@extension("VK_KHR_multiview") define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview"

// 56
@extension("VK_NV_external_memory_capabilities") define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
@extension("VK_NV_external_memory_capabilities") define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"

// 57
@extension("VK_NV_external_memory") define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1
@extension("VK_NV_external_memory") define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"

// 58
@extension("VK_NV_external_memory_win32") define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
@extension("VK_NV_external_memory_win32") define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"

// 59
@extension("VK_NV_win32_keyed_mutex") define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
@extension("VK_NV_win32_keyed_mutex") define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"

// 60
@extension("VK_KHR_get_physical_device_properties2") define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1
@extension("VK_KHR_get_physical_device_properties2") define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"

// 61
@extension("VK_KHR_device_group") define VK_KHR_DEVICE_GROUP_SPEC_VERSION 3
@extension("VK_KHR_device_group") define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group"

// 62
@extension("VK_EXT_validation_flags") define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1
@extension("VK_EXT_validation_flags") define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"

// 63
@extension("VK_NN_vi_surface") define VK_NN_VI_SURFACE_SPEC_VERSION 1
@extension("VK_NN_vi_surface") define VK_NN_VI_SURFACE_EXTENSION_NAME "VK_NN_vi_surface"

// 64
@extension("VK_KHR_shader_draw_parameters") define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1
@extension("VK_KHR_shader_draw_parameters") define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters"

// 65
@extension("VK_EXT_shader_subgroup_ballot") define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1
@extension("VK_EXT_shader_subgroup_ballot") define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot"

// 66
@extension("VK_EXT_shader_subgroup_vote") define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1
@extension("VK_EXT_shader_subgroup_vote") define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"

// 68
@extension("VK_EXT_astc_decode_mode") define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1
@extension("VK_EXT_astc_decode_mode") define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode"

// 70
@extension("VK_KHR_maintenance1") define VK_KHR_MAINTENANCE1_SPEC_VERSION 2
@extension("VK_KHR_maintenance1") define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1"

// 71
@extension("VK_KHR_device_group_creation") define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1
@extension("VK_KHR_device_group_creation") define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation"

// 72
@extension("VK_KHR_external_memory_capabilities") define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
@extension("VK_KHR_external_memory_capabilities") define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities"

// 73
@extension("VK_KHR_external_memory") define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1
@extension("VK_KHR_external_memory") define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory"

// 74
@extension("VK_KHR_external_memory_win32") define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
@extension("VK_KHR_external_memory_win32") define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"

// 75
@extension("VK_KHR_external_memory_fd") define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1
@extension("VK_KHR_external_memory_fd") define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd"

// 76
@extension("VK_KHR_win32_keyed_mutex") define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
@extension("VK_KHR_win32_keyed_mutex") define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"

// 77
@extension("VK_KHR_external_semaphore_capabilities") define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1
@extension("VK_KHR_external_semaphore_capabilities") define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities"

// 78
@extension("VK_KHR_external_semaphore") define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
@extension("VK_KHR_external_semaphore") define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore"

// 79
@extension("VK_KHR_external_semaphore_win32") define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
@extension("VK_KHR_external_semaphore_win32") define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"

// 80
@extension("VK_KHR_external_semaphore_fd") define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1
@extension("VK_KHR_external_semaphore_fd") define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd"

// 81
@extension("VK_KHR_push_descriptor") define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2
@extension("VK_KHR_push_descriptor") define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"

// 82
@extension("VK_EXT_conditional_rendering") define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 1
@extension("VK_EXT_conditional_rendering") define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering"

// 84
@extension("VK_KHR_16bit_storage") define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1
@extension("VK_KHR_16bit_storage") define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"

// 85
@extension("VK_KHR_incremental_present") define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1
@extension("VK_KHR_incremental_present") define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"

// 86
@extension("VK_KHR_descriptor_update_template") define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1
@extension("VK_KHR_descriptor_update_template") define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template"

// 87
@extension("VK_NVX_device_generated_commands") define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3
@extension("VK_NVX_device_generated_commands") define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands"

// 88
@extension("VK_NV_clip_space_w_scaling") define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1
@extension("VK_NV_clip_space_w_scaling") define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling"

// 89
@extension("VK_EXT_direct_mode_display") define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1
@extension("VK_EXT_direct_mode_display") define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display"

// 90
@extension("VK_EXT_acquire_xlib_display") define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
@extension("VK_EXT_acquire_xlib_display") define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display"

// 91
@extension("VK_EXT_display_surface_counter") define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1
@extension("VK_EXT_display_surface_counter") define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter"

// 92
@extension("VK_EXT_display_control") define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1
@extension("VK_EXT_display_control") define VK_EXT_DISPLAY_CONTROL_COUNTER_EXTENSION_NAME "VK_EXT_display_control"

// 93
@extension("VK_GOOGLE_display_timing") define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1
@extension("VK_GOOGLE_display_timing") define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"

// 95
@extension("VK_NV_sample_mask_override_coverage") define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1
@extension("VK_NV_sample_mask_override_coverage") define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage"

// 96
@extension("VK_NV_geometry_shader_passthrough") define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1
@extension("VK_NV_geometry_shader_passthrough") define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough"

// 97
@extension("VK_NV_viewport_array2") define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1
@extension("VK_NV_viewport_array2") define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2"

// 98
@extension("VK_NVX_multiview_per_view_attributes") define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1
@extension("VK_NVX_multiview_per_view_attributes") define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes"

// 99
@extension("VK_NV_viewport_swizzle") define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1
@extension("VK_NV_viewport_swizzle") define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle"

// 100
@extension("VK_EXT_discard_rectangles") define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1
@extension("VK_EXT_discard_rectangles") define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles"

// 102
@extension("VK_EXT_conservative_rasterization") define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1
@extension("VK_EXT_conservative_rasterization") define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization"

// 105
@extension("VK_EXT_swapchain_colorspace") define VK_EXT_SWAPCHAIN_COLORSPACE_SPEC_VERSION 3
@extension("VK_EXT_swapchain_colorspace") define VK_EXT_SWAPCHAIN_COLORSPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"

// 106
@extension("VK_EXT_hdr_metadata") define VK_EXT_HDR_METADATA_SPEC_VERSION 1
@extension("VK_EXT_hdr_metadata") define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"

// 110
@extension("VK_KHR_create_renderpass2") define VK_KHR_CREATE_RENDERPASS2_SPEC_VERSION 1
@extension("VK_KHR_create_renderpass2") define VK_KHR_CREATE_RENDERPASS2_EXTENSION_NAME "VK_KHR_create_renderpass2"

// 112
@extension("VK_KHR_shared_presentable_image") define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
@extension("VK_KHR_shared_presentable_image") define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"

// 113
@extension("VK_KHR_external_fence_capabilities") define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1
@extension("VK_KHR_external_fence_capabilities") define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities"

// 114
@extension("VK_KHR_external_fence") define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1
@extension("VK_KHR_external_fence") define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence"

// 115
@extension("VK_KHR_external_fence_win32") define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
@extension("VK_KHR_external_fence_win32") define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"

// 116
@extension("VK_KHR_external_fence_fd") define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1
@extension("VK_KHR_external_fence_fd") define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd"

// 118
@extension("VK_KHR_maintenance2") define VK_KHR_MAINTENANCE2_SPEC_VERSION 1
@extension("VK_KHR_maintenance2") define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2"

// 120
@extension("VK_KHR_get_surface_capabilities2") define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1
@extension("VK_KHR_get_surface_capabilities2") define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"

// 121
@extension("VK_KHR_variable_pointers") define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1
@extension("VK_KHR_variable_pointers") define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers"

// 122
@extension("VK_KHR_get_display_properties2") define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1
@extension("VK_KHR_get_display_properties2") define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2"

// 123
@extension("VK_MVK_ios_surface") define VK_MVK_IOS_SURFACE_SPEC_VERSION 1
@extension("VK_MVK_ios_surface") define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface"

// 124
@extension("VK_MVK_macos_surface") define VK_MVK_MACOS_SURFACE_SPEC_VERSION 1
@extension("VK_MVK_macos_surface") define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"

// 126
@extension("VK_EXT_external_memory_dma_buf") define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1
@extension("VK_EXT_external_memory_dma_buf") define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf"

// 127
@extension("VK_EXT_queue_family_foreign") define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1
@extension("VK_EXT_queue_family_foreign") define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign"

// 128
@extension("VK_KHR_dedicated_allocation") define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3
@extension("VK_KHR_dedicated_allocation") define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation"

// 128
@extension("VK_EXT_debug_utils") define VK_EXT_DEBUG_UTILS_SPEC_VERSION 1
@extension("VK_EXT_debug_utils") define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils"

// 130
@extension("VK_ANDROID_external_memory_android_hardware_buffer") define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 3
@extension("VK_ANDROID_external_memory_android_hardware_buffer") define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer"

// 131
@extension("VK_EXT_sampler_filter_minmax") define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1
@extension("VK_EXT_sampler_filter_minmax") define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax"

// 132
@extension("VK_KHR_storage_buffer_storage_class") define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1
@extension("VK_KHR_storage_buffer_storage_class") define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class"

// 133
@extension("VK_AMD_gpu_shader_int16") define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 1
@extension("VK_AMD_gpu_shader_int16") define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16"

// 137
@extension("VK_AMD_mixed_attachment_samples") define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1
@extension("VK_AMD_mixed_attachment_samples") define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples"

// 138
@extension("VK_AMD_shader_fragment_mask") define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1
@extension("VK_AMD_shader_fragment_mask") define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask"

// 139
@extension("VK_EXT_inline_uniform_block") define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1
@extension("VK_EXT_inline_uniform_block") define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block"

// 141
@extension("VK_EXT_shader_stencil_export") define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1
@extension("VK_EXT_shader_stencil_export") define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export"

// 144
@extension("VK_EXT_sample_locations") define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1
@extension("VK_EXT_sample_locations") define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations"

// 145
@extension("VK_KHR_relaxed_block_layout") define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1
@extension("VK_KHR_relaxed_block_layout") define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout"

// 147
@extension("VK_KHR_get_memory_requirements2") define VK_KHR_GET_MEMORY_REQUIREMENTS2_SPEC_VERSION 1
@extension("VK_KHR_get_memory_requirements2") define VK_KHR_GET_MEMORY_REQUIREMENTS2_EXTENSION_NAME "VK_KHR_get_memory_requirements2"

// 148
@extension("VK_KHR_image_format_list") define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1
@extension("VK_KHR_image_format_list") define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list"

// 149
@extension("VK_EXT_blend_operation_advanced") define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2
@extension("VK_EXT_blend_operation_advanced") define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced"

// 150
@extension("VK_NV_fragment_coverage_to_color") define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1
@extension("VK_NV_fragment_coverage_to_color") define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color"

// 153
@extension("VK_NV_framebuffer_mixed_samples") define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1
@extension("VK_NV_framebuffer_mixed_samples") define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples"

// 154
@extension("VK_NV_fill_rectangle") define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1
@extension("VK_NV_fill_rectangle") define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle"

// 156
@extension("VK_EXT_post_depth_coverage") define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1
@extension("VK_EXT_post_depth_coverage") define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage"

// 157
@extension("VK_KHR_sampler_ycbcr_conversion") define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 1
@extension("VK_KHR_sampler_ycbcr_conversion") define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"

// 158
@extension("VK_KHR_bind_memory2") define VK_KHR_BIND_MEMORY2_SPEC_VERSION 1
@extension("VK_KHR_bind_memory2") define VK_KHR_BIND_MEMORY2_EXTENSION_NAME "VK_KHR_bind_memory2"

// 159
@extension("VK_EXT_image_drm_format_modifier") define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 1
@extension("VK_EXT_image_drm_format_modifier") define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier"

// 161
@extension("VK_EXT_validation_cache") define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1
@extension("VK_EXT_validation_cache") define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache"

// 162
@extension("VK_EXT_descriptor_indexing") define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2
@extension("VK_EXT_descriptor_indexing") define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing"

// 163
@extension("VK_EXT_shader_viewport_index_layer") define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1
@extension("VK_EXT_shader_viewport_index_layer") define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer"

// 165
@extension("VK_NV_shading_rate_image") define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3
@extension("VK_NV_shading_rate_image") define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image"

// 166
@extension("VK_NVX_raytracing") define VK_NVX_RAYTRACING_SPEC_VERSION 1
@extension("VK_NVX_raytracing") define VK_NVX_RAYTRACING_EXTENSION_NAME "VK_NVX_raytracing"

// 167
@extension("VK_NV_representative_fragment_test") define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 1
@extension("VK_NV_representative_fragment_test") define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test"

// 169
@extension("VK_KHR_maintenance3") define VK_KHR_MAINTENANCE3_SPEC_VERSION 1
@extension("VK_KHR_maintenance3") define VK_KHR_MAINTENANCE3_EXTENSION_NAME "VK_KHR_maintenance3"

// 170
@extension("VK_KHR_draw_indirect_count") define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
@extension("VK_KHR_draw_indirect_count") define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count"

// 175
@extension("VK_EXT_global_priority") define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 1
@extension("VK_EXT_global_priority") define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority"

// 178
@extension("VK_KHR_8bit_storage") define VK_KHR_8BIT_STORAGE_SPEC_VERSION 1
@extension("VK_KHR_8bit_storage") define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage"

// 179
@extension("VK_EXT_external_memory_host") define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1
@extension("VK_EXT_external_memory_host") define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host"

// 180
@extension("VK_AMD_buffer_marker") define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1
@extension("VK_AMD_buffer_marker") define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker"

// 181
@extension("VK_KHR_shader_atomic_int64") define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1
@extension("VK_KHR_shader_atomic_int64") define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64"

// 186
@extension("VK_AMD_shader_core_properties") define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 1
@extension("VK_AMD_shader_core_properties") define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties"

// 191
@extension("VK_EXT_vertex_attribute_divisor") define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 2
@extension("VK_EXT_vertex_attribute_divisor") define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor"

// 197
@extension("VK_KHR_driver_properties") define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1
@extension("VK_KHR_driver_properties") define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties"

// 199
@extension("VK_NV_shader_subgroup_partitioned") define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1
@extension("VK_NV_shader_subgroup_partitioned") define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned"

// 202
@extension("VK_NV_compute_shader_derivatives") define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1
@extension("VK_NV_compute_shader_derivatives") define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives"

// 203
@extension("VK_NV_mesh_shader") define VK_NV_MESH_SHADER_SPEC_VERSION 1
@extension("VK_NV_mesh_shader") define VK_NV_MESH_SHADER_EXTENSION_NAME "VK_NV_mesh_shader"

// 204
@extension("VK_NV_fragment_shader_barycentric") define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1
@extension("VK_NV_fragment_shader_barycentric") define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric"

// 205
@extension("VK_NV_shader_image_footprint") define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 1
@extension("VK_NV_shader_image_footprint") define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint"

// 206
@extension("VK_NV_scissor_exclusive") define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1
@extension("VK_NV_scissor_exclusive") define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive"

// 207
@extension("VK_NV_device_diagnostic_checkpoints") define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2
@extension("VK_NV_device_diagnostic_checkpoints") define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints"

// 212
@extension("VK_KHR_vulkan_memory_model") define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 2
@extension("VK_KHR_vulkan_memory_model") define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model"

// 213
@extension("VK_EXT_pci_bus_info") define VK_EXT_PCI_BUS_INFO_SPEC_VERSION 1
@extension("VK_EXT_pci_bus_info") define VK_EXT_PCI_BUS_INFO_EXENSION_NAME "VK_EXT_pci_bus_info"

// 215
@extension("VK_FUCHSIA_imagepipe_surface") define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1
@extension("VK_FUCHSIA_imagepipe_surface") define VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME "VK_FUCHSIA_imagepipe_surface"

// 224
@extension("VK_GOOGLE_hlsl_functionality1") define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION 0
@extension("VK_GOOGLE_hlsl_functionality1") define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1"

// 225
@extension("VK_GOOGLE_decorate_string") define VK_GOOGLE_DECORATE_STRING_SPEC_VERSION 0
@extension("VK_GOOGLE_decorate_string") define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string"

/////////////
//  Types  //
/////////////

type u32 VkBool32
type u32 VkFlags
type u64 VkDeviceSize
type u32 VkSampleMask

/// Dispatchable handle types.
@dispatchHandle type u64 VkInstance
@dispatchHandle type u64 VkPhysicalDevice
@dispatchHandle type u64 VkDevice
@dispatchHandle type u64 VkQueue
@dispatchHandle type u64 VkCommandBuffer

/// Non dispatchable handle types.
@nonDispatchHandle type u64 VkDeviceMemory
@nonDispatchHandle type u64 VkCommandPool
@nonDispatchHandle type u64 VkBuffer
@nonDispatchHandle type u64 VkBufferView
@nonDispatchHandle type u64 VkImage
@nonDispatchHandle type u64 VkImageView
@nonDispatchHandle type u64 VkShaderModule
@nonDispatchHandle type u64 VkPipeline
@nonDispatchHandle type u64 VkPipelineLayout
@nonDispatchHandle type u64 VkSampler
@nonDispatchHandle type u64 VkDescriptorSet
@nonDispatchHandle type u64 VkDescriptorSetLayout
@nonDispatchHandle type u64 VkDescriptorPool
@nonDispatchHandle type u64 VkFence
@nonDispatchHandle type u64 VkSemaphore
@nonDispatchHandle type u64 VkEvent
@nonDispatchHandle type u64 VkQueryPool
@nonDispatchHandle type u64 VkFramebuffer
@nonDispatchHandle type u64 VkRenderPass
@nonDispatchHandle type u64 VkPipelineCache

@vulkan1_1
@nonDispatchHandle type u64 VkSamplerYcbcrConversion
@nonDispatchHandle type u64 VkDescriptorUpdateTemplate

// 1
@extension("VK_KHR_surface")    @nonDispatchHandle type u64 VkSurfaceKHR

// 2
@extension("VK_KHR_swapchain")  @nonDispatchHandle type u64 VkSwapchainKHR

// 3
@extension("VK_KHR_display")    @nonDispatchHandle type u64 VkDisplayKHR
@extension("VK_KHR_display")    @nonDispatchHandle type u64 VkDisplayModeKHR

// 12
@extension("VK_EXT_debug_report") @nonDispatchHandle type u64 VkDebugReportCallbackEXT

// 86
@extension("VK_KHR_descriptor_update_template") @nonDispatchHandle type u64 VkDescriptorUpdateTemplateKHR

// 87
@extension("VK_NVX_device_generated_commands") @nonDispatchHandle type u64 VkObjectTableNVX
@extension("VK_NVX_device_generated_commands") @nonDispatchHandle type u64 VkIndirectCommandsLayoutNVX

// 129
@extension("VK_EXT_debug_utils") @nonDispatchHandle type u64 VkDebugUtilsMessengerEXT

// 157
@extension("VK_KHR_sampler_ycbcr_conversion") @nonDispatchHandle type u64 VkSamplerYcbcrConversionKHR

// 161
@extension("VK_EXT_validation_cache") @nonDispatchHandle type u64 VkValidationCacheEXT

// 166
@extension("VK_NVX_raytracing") @nonDispatchHandle type u64 VkAccelerationStructureNVX

/////////////
//  Enums  //
/////////////

enum VkImageLayout {
    VK_IMAGE_LAYOUT_UNDEFINED                               = 0x00000000,   /// Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)
    VK_IMAGE_LAYOUT_GENERAL                                 = 0x00000001,   /// General layout when image can be used for any kind of access
    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL                = 0x00000002,   /// Optimal layout when image is only used for color attachment read/write
    VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL        = 0x00000003,   /// Optimal layout when image is only used for depth/stencil attachment read/write
    VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL         = 0x00000004,   /// Optimal layout when image is used for read only depth/stencil attachment and shader access
    VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL                = 0x00000005,   /// Optimal layout when image is used for read only shader access
    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL                    = 0x00000006,   /// Optimal layout when image is used only as source of transfer operations
    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL                    = 0x00000007,   /// Optimal layout when image is used only as destination of transfer operations
    VK_IMAGE_LAYOUT_PREINITIALIZED                          = 0x00000008,   /// Initial layout used when the data is populated by the CPU

    //@vulkan1_1
    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000,
    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001,

    //@extension("VK_KHR_swapchain") // 2
    VK_IMAGE_LAYOUT_PRESENT_SRC_KHR                         = 1000001002,

    //@extension("VK_KHR_shared_presentable_image") // 112
    VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR                      = 1000111000,

    //@extension("VK_KHR_maintenance2") // 118
    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR  = 1000117000,
    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR  = 1000117001,

    //@extension("VK_NV_shading_rate_image") // 165
    VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV                 = 1000164003,
}

enum VkAttachmentLoadOp {
    VK_ATTACHMENT_LOAD_OP_LOAD                              = 0x00000000,
    VK_ATTACHMENT_LOAD_OP_CLEAR                             = 0x00000001,
    VK_ATTACHMENT_LOAD_OP_DONT_CARE                         = 0x00000002,
}

enum VkAttachmentStoreOp {
    VK_ATTACHMENT_STORE_OP_STORE                            = 0x00000000,
    VK_ATTACHMENT_STORE_OP_DONT_CARE                        = 0x00000001,
}

enum VkImageType {
    VK_IMAGE_TYPE_1D                                        = 0x00000000,
    VK_IMAGE_TYPE_2D                                        = 0x00000001,
    VK_IMAGE_TYPE_3D                                        = 0x00000002,
}

enum VkImageTiling {
    VK_IMAGE_TILING_OPTIMAL                                 = 0x00000000,
    VK_IMAGE_TILING_LINEAR                                  = 0x00000001,

    //@extension("VK_EXT_image_drm_format_modifier") // 159
    VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT                 = 1000158000,
}

enum VkImageViewType {
    VK_IMAGE_VIEW_TYPE_1D                                   = 0x00000000,
    VK_IMAGE_VIEW_TYPE_2D                                   = 0x00000001,
    VK_IMAGE_VIEW_TYPE_3D                                   = 0x00000002,
    VK_IMAGE_VIEW_TYPE_CUBE                                 = 0x00000003,
    VK_IMAGE_VIEW_TYPE_1D_ARRAY                             = 0x00000004,
    VK_IMAGE_VIEW_TYPE_2D_ARRAY                             = 0x00000005,
    VK_IMAGE_VIEW_TYPE_CUBE_ARRAY                           = 0x00000006,
}

enum VkCommandBufferLevel {
    VK_COMMAND_BUFFER_LEVEL_PRIMARY                         = 0x00000000,
    VK_COMMAND_BUFFER_LEVEL_SECONDARY                       = 0x00000001,
}

enum VkComponentSwizzle {
    VK_COMPONENT_SWIZZLE_IDENTITY                           = 0x00000000,
    VK_COMPONENT_SWIZZLE_ZERO                               = 0x00000001,
    VK_COMPONENT_SWIZZLE_ONE                                = 0x00000002,
    VK_COMPONENT_SWIZZLE_R                                  = 0x00000003,
    VK_COMPONENT_SWIZZLE_G                                  = 0x00000004,
    VK_COMPONENT_SWIZZLE_B                                  = 0x00000005,
    VK_COMPONENT_SWIZZLE_A                                  = 0x00000006,
}

enum VkDescriptorType {
    VK_DESCRIPTOR_TYPE_SAMPLER                              = 0x00000000,
    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER               = 0x00000001,
    VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE                        = 0x00000002,
    VK_DESCRIPTOR_TYPE_STORAGE_IMAGE                        = 0x00000003,
    VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER                 = 0x00000004,
    VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER                 = 0x00000005,
    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER                       = 0x00000006,
    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER                       = 0x00000007,
    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC               = 0x00000008,
    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC               = 0x00000009,
    VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT                     = 0x0000000a,

    //@extension("VK_EXT_inline_uniform_block") // 139
    VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT             = 1000138000,

    //@extension("VK_NVX_raytracing") // 166
    VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NVX           = 1000165000,
}

enum VkQueryType {
    VK_QUERY_TYPE_OCCLUSION                                 = 0x00000000,
    VK_QUERY_TYPE_PIPELINE_STATISTICS                       = 0x00000001, /// Optional
    VK_QUERY_TYPE_TIMESTAMP                                 = 0x00000002,

    //@extension("VK_EXT_transform_feedback") // 29
    VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT             = 1000028004,

    //@extension("VK_NVX_raytracing") // 166
    VK_QUERY_TYPE_COMPACTED_SIZE_NVX                        = 1000165000,
}

enum VkBorderColor {
    VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK                 = 0x00000000,
    VK_BORDER_COLOR_INT_TRANSPARENT_BLACK                   = 0x00000001,
    VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK                      = 0x00000002,
    VK_BORDER_COLOR_INT_OPAQUE_BLACK                        = 0x00000003,
    VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE                      = 0x00000004,
    VK_BORDER_COLOR_INT_OPAQUE_WHITE                        = 0x00000005,
}

enum VkPipelineBindPoint {
    VK_PIPELINE_BIND_POINT_GRAPHICS                         = 0x00000000,
    VK_PIPELINE_BIND_POINT_COMPUTE                          = 0x00000001,

    //@extension("VK_NVX_raytracing") // 166
    VK_PIPELINE_BIND_POINT_RAYTRACING_NVX                   = 1000165000,
}

enum VkPrimitiveTopology {
    VK_PRIMITIVE_TOPOLOGY_POINT_LIST                        = 0x00000000,
    VK_PRIMITIVE_TOPOLOGY_LINE_LIST                         = 0x00000001,
    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP                        = 0x00000002,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST                     = 0x00000003,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP                    = 0x00000004,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN                      = 0x00000005,
    VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY          = 0x00000006,
    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY         = 0x00000007,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY      = 0x00000008,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY     = 0x00000009,
    VK_PRIMITIVE_TOPOLOGY_PATCH_LIST                        = 0x0000000a,
}

enum VkSharingMode {
    VK_SHARING_MODE_EXCLUSIVE                               = 0x00000000,
    VK_SHARING_MODE_CONCURRENT                              = 0x00000001,
}

enum VkIndexType {
    VK_INDEX_TYPE_UINT16                                    = 0x00000000,
    VK_INDEX_TYPE_UINT32                                    = 0x00000001,
}

enum VkFilter {
    VK_FILTER_NEAREST                                       = 0x00000000,
    VK_FILTER_LINEAR                                        = 0x00000001,

    //@extension("VK_IMG_filter_cubic") // 16
    VK_FILTER_CUBIC_IMG                                     = 1000015000,
}

enum VkSamplerMipmapMode {
    VK_SAMPLER_MIPMAP_MODE_NEAREST                          = 0x00000001,   /// Choose nearest mip level
    VK_SAMPLER_MIPMAP_MODE_LINEAR                           = 0x00000002,   /// Linear filter between mip levels
}

enum VkSamplerAddressMode {
    VK_SAMPLER_ADDRESS_MODE_REPEAT                          = 0x00000000,
    VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT                 = 0x00000001,
    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE                   = 0x00000002,
    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER                 = 0x00000003,
    VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE            = 0x00000004,
}

enum VkCompareOp {
    VK_COMPARE_OP_NEVER                                     = 0x00000000,
    VK_COMPARE_OP_LESS                                      = 0x00000001,
    VK_COMPARE_OP_EQUAL                                     = 0x00000002,
    VK_COMPARE_OP_LESS_OR_EQUAL                             = 0x00000003,
    VK_COMPARE_OP_GREATER                                   = 0x00000004,
    VK_COMPARE_OP_NOT_EQUAL                                 = 0x00000005,
    VK_COMPARE_OP_GREATER_OR_EQUAL                          = 0x00000006,
    VK_COMPARE_OP_ALWAYS                                    = 0x00000007,
}

enum VkPolygonMode {
    VK_POLYGON_MODE_FILL                                    = 0x00000000,
    VK_POLYGON_MODE_LINE                                    = 0x00000001,
    VK_POLYGON_MODE_POINT                                   = 0x00000002,

    //@extension("VK_NV_fill_rectangle") // 154
    VK_POLYGON_MODE_FILL_RECTANGLE_NV                       = 1000153000,
}

enum VkFrontFace {
    VK_FRONT_FACE_COUNTER_CLOCKWISE                         = 0x00000000,
    VK_FRONT_FACE_CLOCKWISE                                 = 0x00000001,
}

enum VkBlendFactor {
    VK_BLEND_FACTOR_ZERO                                    = 0x00000000,
    VK_BLEND_FACTOR_ONE                                     = 0x00000001,
    VK_BLEND_FACTOR_SRC_COLOR                               = 0x00000002,
    VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR                     = 0x00000003,
    VK_BLEND_FACTOR_DST_COLOR                               = 0x00000004,
    VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR                     = 0x00000005,
    VK_BLEND_FACTOR_SRC_ALPHA                               = 0x00000006,
    VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA                     = 0x00000007,
    VK_BLEND_FACTOR_DST_ALPHA                               = 0x00000008,
    VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA                     = 0x00000009,
    VK_BLEND_FACTOR_CONSTANT_COLOR                          = 0x0000000a,
    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR                = 0x0000000b,
    VK_BLEND_FACTOR_CONSTANT_ALPHA                          = 0x0000000c,
    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA                = 0x0000000d,
    VK_BLEND_FACTOR_SRC_ALPHA_SATURATE                      = 0x0000000e,
    VK_BLEND_FACTOR_SRC1_COLOR                              = 0x0000000f,
    VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR                    = 0x00000010,
    VK_BLEND_FACTOR_SRC1_ALPHA                              = 0x00000011,
    VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA                    = 0x00000012,
}

enum VkBlendOp {
    VK_BLEND_OP_ADD                                         = 0x00000000,
    VK_BLEND_OP_SUBTRACT                                    = 0x00000001,
    VK_BLEND_OP_REVERSE_SUBTRACT                            = 0x00000002,
    VK_BLEND_OP_MIN                                         = 0x00000003,
    VK_BLEND_OP_MAX                                         = 0x00000004,

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

enum VkStencilOp {
    VK_STENCIL_OP_KEEP                                      = 0x00000000,
    VK_STENCIL_OP_ZERO                                      = 0x00000001,
    VK_STENCIL_OP_REPLACE                                   = 0x00000002,
    VK_STENCIL_OP_INCREMENT_AND_CLAMP                       = 0x00000003,
    VK_STENCIL_OP_DECREMENT_AND_CLAMP                       = 0x00000004,
    VK_STENCIL_OP_INVERT                                    = 0x00000005,
    VK_STENCIL_OP_INCREMENT_AND_WRAP                        = 0x00000006,
    VK_STENCIL_OP_DECREMENT_AND_WRAP                        = 0x00000007,
}

enum VkLogicOp {
    VK_LOGIC_OP_CLEAR                                       = 0x00000000,
    VK_LOGIC_OP_AND                                         = 0x00000001,
    VK_LOGIC_OP_AND_REVERSE                                 = 0x00000002,
    VK_LOGIC_OP_COPY                                        = 0x00000003,
    VK_LOGIC_OP_AND_INVERTED                                = 0x00000004,
    VK_LOGIC_OP_NO_OP                                       = 0x00000005,
    VK_LOGIC_OP_XOR                                         = 0x00000006,
    VK_LOGIC_OP_OR                                          = 0x00000007,
    VK_LOGIC_OP_NOR                                         = 0x00000008,
    VK_LOGIC_OP_EQUIVALENT                                  = 0x00000009,
    VK_LOGIC_OP_INVERT                                      = 0x0000000a,
    VK_LOGIC_OP_OR_REVERSE                                  = 0x0000000b,
    VK_LOGIC_OP_COPY_INVERTED                               = 0x0000000c,
    VK_LOGIC_OP_OR_INVERTED                                 = 0x0000000d,
    VK_LOGIC_OP_NAND                                        = 0x0000000e,
    VK_LOGIC_OP_SET                                         = 0x0000000f,
}

enum VkSystemAllocationScope {
    VK_SYSTEM_ALLOCATION_SCOPE_COMMAND                      = 0x00000000,
    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT                       = 0x00000001,
    VK_SYSTEM_ALLOCATION_SCOPE_CACHE                        = 0x00000002,
    VK_SYSTEM_ALLOCATION_SCOPE_DEVICE                       = 0x00000003,
    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE                     = 0x00000004,
}

enum VkInternalAllocationType {
    VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE                  = 0x00000000,
}

enum VkPhysicalDeviceType {
    VK_PHYSICAL_DEVICE_TYPE_OTHER                           = 0x00000000,
    VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU                  = 0x00000001,
    VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU                    = 0x00000002,
    VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU                     = 0x00000003,
    VK_PHYSICAL_DEVICE_TYPE_CPU                             = 0x00000004,
}

enum VkVertexInputRate {
    VK_VERTEX_INPUT_RATE_VERTEX                             = 0x00000000,
    VK_VERTEX_INPUT_RATE_INSTANCE                           = 0x00000001,
}

/// Vulkan format definitions
enum VkFormat {
    VK_FORMAT_UNDEFINED                                     = 0,
    VK_FORMAT_R4G4_UNORM_PACK8                              = 1,
    VK_FORMAT_R4G4B4A4_UNORM_PACK16                         = 2,
    VK_FORMAT_B4G4R4A4_UNORM_PACK16                         = 3,
    VK_FORMAT_R5G6B5_UNORM_PACK16                           = 4,
    VK_FORMAT_B5G6R5_UNORM_PACK16                           = 5,
    VK_FORMAT_R5G5B5A1_UNORM_PACK16                         = 6,
    VK_FORMAT_B5G5R5A1_UNORM_PACK16                         = 7,
    VK_FORMAT_A1R5G5B5_UNORM_PACK16                         = 8,
    VK_FORMAT_R8_UNORM                                      = 9,
    VK_FORMAT_R8_SNORM                                      = 10,
    VK_FORMAT_R8_USCALED                                    = 11,
    VK_FORMAT_R8_SSCALED                                    = 12,
    VK_FORMAT_R8_UINT                                       = 13,
    VK_FORMAT_R8_SINT                                       = 14,
    VK_FORMAT_R8_SRGB                                       = 15,
    VK_FORMAT_R8G8_UNORM                                    = 16,
    VK_FORMAT_R8G8_SNORM                                    = 17,
    VK_FORMAT_R8G8_USCALED                                  = 18,
    VK_FORMAT_R8G8_SSCALED                                  = 19,
    VK_FORMAT_R8G8_UINT                                     = 20,
    VK_FORMAT_R8G8_SINT                                     = 21,
    VK_FORMAT_R8G8_SRGB                                     = 22,
    VK_FORMAT_R8G8B8_UNORM                                  = 23,
    VK_FORMAT_R8G8B8_SNORM                                  = 24,
    VK_FORMAT_R8G8B8_USCALED                                = 25,
    VK_FORMAT_R8G8B8_SSCALED                                = 26,
    VK_FORMAT_R8G8B8_UINT                                   = 27,
    VK_FORMAT_R8G8B8_SINT                                   = 28,
    VK_FORMAT_R8G8B8_SRGB                                   = 29,
    VK_FORMAT_B8G8R8_UNORM                                  = 30,
    VK_FORMAT_B8G8R8_SNORM                                  = 31,
    VK_FORMAT_B8G8R8_USCALED                                = 32,
    VK_FORMAT_B8G8R8_SSCALED                                = 33,
    VK_FORMAT_B8G8R8_UINT                                   = 34,
    VK_FORMAT_B8G8R8_SINT                                   = 35,
    VK_FORMAT_B8G8R8_SRGB                                   = 36,
    VK_FORMAT_R8G8B8A8_UNORM                                = 37,
    VK_FORMAT_R8G8B8A8_SNORM                                = 38,
    VK_FORMAT_R8G8B8A8_USCALED                              = 39,
    VK_FORMAT_R8G8B8A8_SSCALED                              = 40,
    VK_FORMAT_R8G8B8A8_UINT                                 = 41,
    VK_FORMAT_R8G8B8A8_SINT                                 = 42,
    VK_FORMAT_R8G8B8A8_SRGB                                 = 43,
    VK_FORMAT_B8G8R8A8_UNORM                                = 44,
    VK_FORMAT_B8G8R8A8_SNORM                                = 45,
    VK_FORMAT_B8G8R8A8_USCALED                              = 46,
    VK_FORMAT_B8G8R8A8_SSCALED                              = 47,
    VK_FORMAT_B8G8R8A8_UINT                                 = 48,
    VK_FORMAT_B8G8R8A8_SINT                                 = 49,
    VK_FORMAT_B8G8R8A8_SRGB                                 = 50,
    VK_FORMAT_A8B8G8R8_UNORM_PACK32                         = 51,
    VK_FORMAT_A8B8G8R8_SNORM_PACK32                         = 52,
    VK_FORMAT_A8B8G8R8_USCALED_PACK32                       = 53,
    VK_FORMAT_A8B8G8R8_SSCALED_PACK32                       = 54,
    VK_FORMAT_A8B8G8R8_UINT_PACK32                          = 55,
    VK_FORMAT_A8B8G8R8_SINT_PACK32                          = 56,
    VK_FORMAT_A8B8G8R8_SRGB_PACK32                          = 57,
    VK_FORMAT_A2R10G10B10_UNORM_PACK32                      = 58,
    VK_FORMAT_A2R10G10B10_SNORM_PACK32                      = 59,
    VK_FORMAT_A2R10G10B10_USCALED_PACK32                    = 60,
    VK_FORMAT_A2R10G10B10_SSCALED_PACK32                    = 61,
    VK_FORMAT_A2R10G10B10_UINT_PACK32                       = 62,
    VK_FORMAT_A2R10G10B10_SINT_PACK32                       = 63,
    VK_FORMAT_A2B10G10R10_UNORM_PACK32                      = 64,
    VK_FORMAT_A2B10G10R10_SNORM_PACK32                      = 65,
    VK_FORMAT_A2B10G10R10_USCALED_PACK32                    = 66,
    VK_FORMAT_A2B10G10R10_SSCALED_PACK32                    = 67,
    VK_FORMAT_A2B10G10R10_UINT_PACK32                       = 68,
    VK_FORMAT_A2B10G10R10_SINT_PACK32                       = 69,
    VK_FORMAT_R16_UNORM                                     = 70,
    VK_FORMAT_R16_SNORM                                     = 71,
    VK_FORMAT_R16_USCALED                                   = 72,
    VK_FORMAT_R16_SSCALED                                   = 73,
    VK_FORMAT_R16_UINT                                      = 74,
    VK_FORMAT_R16_SINT                                      = 75,
    VK_FORMAT_R16_SFLOAT                                    = 76,
    VK_FORMAT_R16G16_UNORM                                  = 77,
    VK_FORMAT_R16G16_SNORM                                  = 78,
    VK_FORMAT_R16G16_USCALED                                = 79,
    VK_FORMAT_R16G16_SSCALED                                = 80,
    VK_FORMAT_R16G16_UINT                                   = 81,
    VK_FORMAT_R16G16_SINT                                   = 82,
    VK_FORMAT_R16G16_SFLOAT                                 = 83,
    VK_FORMAT_R16G16B16_UNORM                               = 84,
    VK_FORMAT_R16G16B16_SNORM                               = 85,
    VK_FORMAT_R16G16B16_USCALED                             = 86,
    VK_FORMAT_R16G16B16_SSCALED                             = 87,
    VK_FORMAT_R16G16B16_UINT                                = 88,
    VK_FORMAT_R16G16B16_SINT                                = 89,
    VK_FORMAT_R16G16B16_SFLOAT                              = 90,
    VK_FORMAT_R16G16B16A16_UNORM                            = 91,
    VK_FORMAT_R16G16B16A16_SNORM                            = 92,
    VK_FORMAT_R16G16B16A16_USCALED                          = 93,
    VK_FORMAT_R16G16B16A16_SSCALED                          = 94,
    VK_FORMAT_R16G16B16A16_UINT                             = 95,
    VK_FORMAT_R16G16B16A16_SINT                             = 96,
    VK_FORMAT_R16G16B16A16_SFLOAT                           = 97,
    VK_FORMAT_R32_UINT                                      = 98,
    VK_FORMAT_R32_SINT                                      = 99,
    VK_FORMAT_R32_SFLOAT                                    = 100,
    VK_FORMAT_R32G32_UINT                                   = 101,
    VK_FORMAT_R32G32_SINT                                   = 102,
    VK_FORMAT_R32G32_SFLOAT                                 = 103,
    VK_FORMAT_R32G32B32_UINT                                = 104,
    VK_FORMAT_R32G32B32_SINT                                = 105,
    VK_FORMAT_R32G32B32_SFLOAT                              = 106,
    VK_FORMAT_R32G32B32A32_UINT                             = 107,
    VK_FORMAT_R32G32B32A32_SINT                             = 108,
    VK_FORMAT_R32G32B32A32_SFLOAT                           = 109,
    VK_FORMAT_R64_UINT                                      = 110,
    VK_FORMAT_R64_SINT                                      = 111,
    VK_FORMAT_R64_SFLOAT                                    = 112,
    VK_FORMAT_R64G64_UINT                                   = 113,
    VK_FORMAT_R64G64_SINT                                   = 114,
    VK_FORMAT_R64G64_SFLOAT                                 = 115,
    VK_FORMAT_R64G64B64_UINT                                = 116,
    VK_FORMAT_R64G64B64_SINT                                = 117,
    VK_FORMAT_R64G64B64_SFLOAT                              = 118,
    VK_FORMAT_R64G64B64A64_UINT                             = 119,
    VK_FORMAT_R64G64B64A64_SINT                             = 120,
    VK_FORMAT_R64G64B64A64_SFLOAT                           = 121,
    VK_FORMAT_B10G11R11_UFLOAT_PACK32                       = 122,
    VK_FORMAT_E5B9G9R9_UFLOAT_PACK32                        = 123,
    VK_FORMAT_D16_UNORM                                     = 124,
    VK_FORMAT_X8_D24_UNORM_PACK32                           = 125,
    VK_FORMAT_D32_SFLOAT                                    = 126,
    VK_FORMAT_S8_UINT                                       = 127,
    VK_FORMAT_D16_UNORM_S8_UINT                             = 128,
    VK_FORMAT_D24_UNORM_S8_UINT                             = 129,
    VK_FORMAT_D32_SFLOAT_S8_UINT                            = 130,
    VK_FORMAT_BC1_RGB_UNORM_BLOCK                           = 131,
    VK_FORMAT_BC1_RGB_SRGB_BLOCK                            = 132,
    VK_FORMAT_BC1_RGBA_UNORM_BLOCK                          = 133,
    VK_FORMAT_BC1_RGBA_SRGB_BLOCK                           = 134,
    VK_FORMAT_BC2_UNORM_BLOCK                               = 135,
    VK_FORMAT_BC2_SRGB_BLOCK                                = 136,
    VK_FORMAT_BC3_UNORM_BLOCK                               = 137,
    VK_FORMAT_BC3_SRGB_BLOCK                                = 138,
    VK_FORMAT_BC4_UNORM_BLOCK                               = 139,
    VK_FORMAT_BC4_SNORM_BLOCK                               = 140,
    VK_FORMAT_BC5_UNORM_BLOCK                               = 141,
    VK_FORMAT_BC5_SNORM_BLOCK                               = 142,
    VK_FORMAT_BC6H_UFLOAT_BLOCK                             = 143,
    VK_FORMAT_BC6H_SFLOAT_BLOCK                             = 144,
    VK_FORMAT_BC7_UNORM_BLOCK                               = 145,
    VK_FORMAT_BC7_SRGB_BLOCK                                = 146,
    VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK                       = 147,
    VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK                        = 148,
    VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK                     = 149,
    VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK                      = 150,
    VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK                     = 151,
    VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK                      = 152,
    VK_FORMAT_EAC_R11_UNORM_BLOCK                           = 153,
    VK_FORMAT_EAC_R11_SNORM_BLOCK                           = 154,
    VK_FORMAT_EAC_R11G11_UNORM_BLOCK                        = 155,
    VK_FORMAT_EAC_R11G11_SNORM_BLOCK                        = 156,
    VK_FORMAT_ASTC_4x4_UNORM_BLOCK                          = 157,
    VK_FORMAT_ASTC_4x4_SRGB_BLOCK                           = 158,
    VK_FORMAT_ASTC_5x4_UNORM_BLOCK                          = 159,
    VK_FORMAT_ASTC_5x4_SRGB_BLOCK                           = 160,
    VK_FORMAT_ASTC_5x5_UNORM_BLOCK                          = 161,
    VK_FORMAT_ASTC_5x5_SRGB_BLOCK                           = 162,
    VK_FORMAT_ASTC_6x5_UNORM_BLOCK                          = 163,
    VK_FORMAT_ASTC_6x5_SRGB_BLOCK                           = 164,
    VK_FORMAT_ASTC_6x6_UNORM_BLOCK                          = 165,
    VK_FORMAT_ASTC_6x6_SRGB_BLOCK                           = 166,
    VK_FORMAT_ASTC_8x5_UNORM_BLOCK                          = 167,
    VK_FORMAT_ASTC_8x5_SRGB_BLOCK                           = 168,
    VK_FORMAT_ASTC_8x6_UNORM_BLOCK                          = 169,
    VK_FORMAT_ASTC_8x6_SRGB_BLOCK                           = 170,
    VK_FORMAT_ASTC_8x8_UNORM_BLOCK                          = 171,
    VK_FORMAT_ASTC_8x8_SRGB_BLOCK                           = 172,
    VK_FORMAT_ASTC_10x5_UNORM_BLOCK                         = 173,
    VK_FORMAT_ASTC_10x5_SRGB_BLOCK                          = 174,
    VK_FORMAT_ASTC_10x6_UNORM_BLOCK                         = 175,
    VK_FORMAT_ASTC_10x6_SRGB_BLOCK                          = 176,
    VK_FORMAT_ASTC_10x8_UNORM_BLOCK                         = 177,
    VK_FORMAT_ASTC_10x8_SRGB_BLOCK                          = 178,
    VK_FORMAT_ASTC_10x10_UNORM_BLOCK                        = 179,
    VK_FORMAT_ASTC_10x10_SRGB_BLOCK                         = 180,
    VK_FORMAT_ASTC_12x10_UNORM_BLOCK                        = 181,
    VK_FORMAT_ASTC_12x10_SRGB_BLOCK                         = 182,
    VK_FORMAT_ASTC_12x12_UNORM_BLOCK                        = 183,
    VK_FORMAT_ASTC_12x12_SRGB_BLOCK                         = 184,

    //@vulkan1_1
    VK_FORMAT_G8B8G8R8_422_UNORM                            = 1000156000,
    VK_FORMAT_B8G8R8G8_422_UNORM                            = 1000156001,
    VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM                     = 1000156002,
    VK_FORMAT_G8_B8R8_2PLANE_420_UNORM                      = 1000156003,
    VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM                     = 1000156004,
    VK_FORMAT_G8_B8R8_2PLANE_422_UNORM                      = 1000156005,
    VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM                     = 1000156006,
    VK_FORMAT_R10X6_UNORM_PACK16                            = 1000156007,
    VK_FORMAT_R10X6G10X6_UNORM_2PACK16                      = 1000156008,
    VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16            = 1000156009,
    VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16        = 1000156010,
    VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16        = 1000156011,
    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16    = 1000156012,
    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16     = 1000156013,
    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16    = 1000156014,
    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16     = 1000156015,
    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16    = 1000156016,
    VK_FORMAT_R12X4_UNORM_PACK16                            = 1000156017,
    VK_FORMAT_R12X4G12X4_UNORM_2PACK16                      = 1000156018,
    VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16            = 1000156019,
    VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16        = 1000156020,
    VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16        = 1000156021,
    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16    = 1000156022,
    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16     = 1000156023,
    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16    = 1000156024,
    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16     = 1000156025,
    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16    = 1000156026,
    VK_FORMAT_G16B16G16R16_422_UNORM                        = 1000156027,
    VK_FORMAT_B16G16R16G16_422_UNORM                        = 1000156028,
    VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM                  = 1000156029,
    VK_FORMAT_G16_B16R16_2PLANE_420_UNORM                   = 1000156030,
    VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM                  = 1000156031,
    VK_FORMAT_G16_B16R16_2PLANE_422_UNORM                   = 1000156032,
    VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM                  = 1000156033,

    //@extension("VK_IMG_format_pvrtc") // 28
    VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG                   = 1000054000,
    VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG                   = 1000054001,
    VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG                   = 1000054002,
    VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG                   = 1000054003,
    VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG                    = 1000054004,
    VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG                    = 1000054005,
    VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG                    = 1000054006,
    VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG                    = 1000054007,

    //@extension("VK_KHR_sampler_ycbcr_conversion") // 157
    VK_FORMAT_G8B8G8R8_422_UNORM_KHR                            = 1000156000,
    VK_FORMAT_B8G8R8G8_422_UNORM_KHR                            = 1000156001,
    VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR                     = 1000156002,
    VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR                      = 1000156003,
    VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR                     = 1000156004,
    VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR                      = 1000156005,
    VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR                     = 1000156006,
    VK_FORMAT_R10X6_UNORM_PACK16_KHR                            = 1000156007,
    VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR                      = 1000156008,
    VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR            = 1000156009,
    VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR        = 1000156010,
    VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR        = 1000156011,
    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR    = 1000156012,
    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR     = 1000156013,
    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR    = 1000156014,
    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR     = 1000156015,
    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR    = 1000156016,
    VK_FORMAT_R12X4_UNORM_PACK16_KHR                            = 1000156017,
    VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR                      = 1000156018,
    VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR            = 1000156019,
    VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR        = 1000156020,
    VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR        = 1000156021,
    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR    = 1000156022,
    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR     = 1000156023,
    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR    = 1000156024,
    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR     = 1000156025,
    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR    = 1000156026,
    VK_FORMAT_G16B16G16R16_422_UNORM_KHR                        = 1000156027,
    VK_FORMAT_B16G16R16G16_422_UNORM_KHR                        = 1000156028,
    VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR                  = 1000156029,
    VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR                   = 1000156030,
    VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR                  = 1000156031,
    VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR                   = 1000156032,
    VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR                  = 1000156033,
}

/// Structure type enumerant
enum VkStructureType {
    VK_STRUCTURE_TYPE_APPLICATION_INFO                          = 0,
    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO                      = 1,
    VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO                  = 2,
    VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO                        = 3,
    VK_STRUCTURE_TYPE_SUBMIT_INFO                               = 4,
    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO                      = 5,
    VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE                       = 6,
    VK_STRUCTURE_TYPE_BIND_SPARSE_INFO                          = 7,
    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO                         = 8,
    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO                     = 9,
    VK_STRUCTURE_TYPE_EVENT_CREATE_INFO                         = 10,
    VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO                    = 11,
    VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO                        = 12,
    VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO                   = 13,
    VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO                         = 14,
    VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO                    = 15,
    VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO                 = 16,
    VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO                = 17,
    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO         = 18,
    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO   = 19,
    VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO   = 21,
    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO       = 22,
    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO  = 23,
    VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO    = 24,
    VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO  = 25,
    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO    = 26,
    VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO        = 27,
    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO             = 28,
    VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO              = 29,
    VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO               = 30,
    VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO                       = 31,
    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO         = 32,
    VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO               = 33,
    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO              = 34,
    VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET                      = 35,
    VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET                       = 36,
    VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO                   = 37,
    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO                   = 38,
    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO                  = 39,
    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO              = 40,
    VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO           = 41,
    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO                 = 42,
    VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO                    = 43,
    VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER                     = 44,
    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER                      = 45,
    VK_STRUCTURE_TYPE_MEMORY_BARRIER                            = 46,
    VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO               = 47,
    VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO                 = 48,

    //@vulkan1_1
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES       = 1000094000,
    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO                   = 1000157000,
    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO                    = 1000157001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES    = 1000083000,
    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS             = 1000127000,
    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO            = 1000127001,
    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO                = 1000060000,
    VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO       = 1000060003,
    VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO    = 1000060004,
    VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO                  = 1000060005,
    VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO             = 1000060006,
    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO      = 1000060013,
    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO       = 1000060014,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES          = 1000070000,
    VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO           = 1000070001,
    VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2         = 1000146000,
    VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2          = 1000146001,
    VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2   = 1000146002,
    VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2                     = 1000146003,
    VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2        = 1000146004,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2                = 1000059000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2              = 1000059001,
    VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2                       = 1000059002,
    VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2                 = 1000059003,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2       = 1000059004,
    VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2                 = 1000059005,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2       = 1000059006,
    VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2          = 1000059007,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2            = 1000059008,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES             = 1000117000,
    VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO       = 1000117001,
    VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO                          = 1000117002,
    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003,
    VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO                 = 1000053000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES                = 1000053001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES              = 1000053002,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES         = 1000120000,
    VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO                             = 1000145000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES         = 1000145001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES       = 1000145002,
    VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2                               = 1000145003,
    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO              = 1000156000,
    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO                     = 1000156001,
    VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO                      = 1000156002,
    VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO              = 1000156003,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004,
    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES  = 1000156005,
    VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO            = 1000085000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO        = 1000071000,
    VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES                  = 1000071001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO              = 1000071002,
    VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES                        = 1000071003,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES                     = 1000071004,
    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO                = 1000072000,
    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO                 = 1000072001,
    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO                       = 1000072002,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO               = 1000112000,
    VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES                         = 1000112001,
    VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO                          = 1000113000,
    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO                      = 1000077000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO           = 1000076000,
    VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES                     = 1000076001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES          = 1000168000,
    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT                     = 1000168001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES    = 1000063000,
    VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR             = 1000060007,

    //@extension("VK_KHR_swapchain") // 2
    VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR                 = 1000001000,
    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR                          = 1000001001,
    // added as interaction from VK_KHR_device_group / VK 1.1
    VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR           = 1000060008,
    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR      = 1000060009,
    VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR               = 1000060010,
    VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR             = 1000060011,
    VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR    = 1000060012,

    //@extension("VK_KHR_display") // 3
    VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR              = 1000002000,
    VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR           = 1000002001,

    //@extension("VK_KHR_display_swapchain") // 4
    VK_STRUCTURE_TYPE_DISPLAY_DISPLAY_PRESENT_INFO_KHR          = 1000003000,

    //@extension("VK_KHR_xlib_surface") // 5
    VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR              = 1000004000,

    //@extension("VK_KHR_xcb_surface") // 6
    VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR               = 1000005000,

    //@extension("VK_KHR_wayland_surface") // 7
    VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR           = 1000006000,

    //@extension("VK_KHR_mir_surface") // 8
    VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR               = 1000007000,

    //@extension("VK_KHR_android_surface") // 9
    VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR           = 1000008000,

    //@extension("VK_KHR_win32_surface") // 10
    VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR             = 1000009000,

    //@extension("VK_ANDROID_native_buffer") // 11
    VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID                     = 1000010000,
    VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID       = 1000010001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID = 1000010002,

    //@extension("VK_EXT_debug_report") // 12
    VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT     = 1000011000,

    //@extension("VK_AMD_rasterization_order") // 19
    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,

    //@extension("VK_EXT_debug_marker") // 23
    VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT         = 1000022000,
    VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT          = 1000022001,
    VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT              = 1000022002,

    //@extension("VK_NV_dedicated_allocation") // 27
    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,

    //@extension("VK_EXT_transform_feedback") // 29
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT       = 1000028000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT     = 1000028001,
    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT   = 1000028002,

    //@extension("VK_AMD_texture_gather_bias_lod") // 42
    VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD  = 1000041000,

    //@extension("VK_NV_corner_sampled_image") // 51
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV  = 1000050000,

    //@extension("VK_KHR_multiview") // 54
    VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR     = 1000053000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR    = 1000053001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR  = 1000053002,

    //@extension("VK_NV_external_memory") // 57
    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV      = 1000056000,
    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV            = 1000056001,

    //@extension("VK_NV_external_memory_win32") // 58
    VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV        = 1000057000,
    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV        = 1000057001,

    //@extension("VK_NV_win32_keyed_mutex") // 59
    VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,

    //@extension("VK_KHR_get_physical_device_properties2") // 60
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR            = 1000059000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR          = 1000059001,
    VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR                   = 1000059002,
    VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR             = 1000059003,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR   = 1000059004,
    VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR             = 1000059005,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR   = 1000059006,
    VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR      = 1000059007,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008,

    //@extension("VK_KHR_device_group") // 61
    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR            = 1000060000,
    VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR   = 1000060003,
    VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = 1000060004,
    VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR              = 1000060005,
    VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR         = 1000060006,
    VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR     = 1000060007,
    // tokens 08-12 are listed with VK_KHR_swapchain
    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR  = 1000060013,
    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR   = 1000060014,

    //@extension("VK_EXT_validation_flags") // 62
    VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT                      = 1000061000,

    //@extension("VK_NN_vi_surface") // 63
    VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN                 = 1000062000,

    //@extension("VK_EXT_astc_decode_mode") // 68
    VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT           = 1000067000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT  = 1000067001,

    //@extension("VK_KHR_device_group_creation") // 71
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR      = 1000070000,
    VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR       = 1000070001,

    //@extension("VK_KHR_external_memory_capabilities") // 72
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR    = 1000071000,
    VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR      = 1000071001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR  = 1000071002,
    VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR            = 1000071003,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR         = 1000071004,

    //@extension("VK_KHR_external_memory") // 73
    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR    = 1000072000,
    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR     = 1000072001,
    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR           = 1000072002,

    //@extension("VK_KHR_external_memory_win32") // 74
    VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR       = 1000073000,
    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR       = 1000073001,
    VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR        = 1000073002,

    //@extension("VK_KHR_external_memory_fd") // 75
    VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR                 = 1000074000,
    VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR                  = 1000074001,

    //@extension("VK_KHR_win32_keyed_mutex") // 76
    VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR    = 1000075000,

    //@extension("VK_KHR_external_semaphore_capabilities") // 77
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR   = 1000076000,
    VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR         = 1000076001,

    //@extension("VK_KHR_external_semaphore") // 78
    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR          = 1000077000,

    //@extension("VK_KHR_external_semaphore_win32") // 79
    VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR    = 1000078000,
    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR    = 1000078001,
    VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR               = 1000078002,

    //@extension("VK_KHR_external_semaphore_fd") // 80
    VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR              = 1000079000,
    VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR                 = 1000079001,

    //@extension("VK_KHR_push_descriptor") // 81
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR    = 1000080000,

    //@extension("VK_KHR_16bit_storage") // 84
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR    = 1000083000,

    //@extension("VK_KHR_incremental_present") // 85
    VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR                       = 1000084000,

    //@extension("VK_EXT_conditional_rendering") // 82
    VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT        = 1000081001,
    VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT                      = 1000081002,

    //@extension("VK_KHR_descriptor_update_template") // 86
    VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR    = 1000085000,

    //@extension("VK_NVX_device_generated_commands") // 87
    VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX              = 1000086000,
    VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX  = 1000086001,
    VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX             = 1000086002,
    VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX   = 1000086003,
    VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX      = 1000086004,
    VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX    = 1000086005,

    //@extension("VK_NV_clip_space_w_scaling") // 88
    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV  = 1000087000,

    //@extension("VK_EXT_display_surface_counter") // 91
    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT                = 1000090000,

    //@extension("VK_EXT_display_control") // 92
    VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT                    = 1000091000,
    VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT                     = 1000091001,
    VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT                    = 1000091002,
    VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT         = 1000091003,

    //@extension("VK_GOOGLE_display_timing") // 93
    VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE                 = 1000092000,

    //@extension("VK_NVX_multiview_per_view_attributes") // 98
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX  = 1000097000,

    //@extension("VK_NV_viewport_swizzle") // 99
    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV    = 1000098000,

    //@extension("VK_EXT_discard_rectangles") // 100
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT  = 1000099000,
    VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT  = 1000099001,

    //@extension("VK_EXT_conservative_rasterization") // 102
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000,
    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001,

    //@extension("VK_KHR_create_renderpass2") // 110
    VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR              = 1000109000,
    VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR                = 1000109001,
    VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR                 = 1000109002,
    VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR                  = 1000109003,
    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR             = 1000109004,
    VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR                    = 1000109005,
    VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR                      = 1000109006,

    //@extension("VK_EXT_hdr_metadata") // 106
    VK_STRUCTURE_TYPE_HDR_METADATA_EXT                          = 1000105000,

    //@extension("VK_KHR_shared_presentable_image") // 112
    VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR   = 1000111000,

    //@extension("VK_KHR_external_fence_capabilities") // 113
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR   = 1000112000,
    VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR             = 1000112001,

    //@extension("VK_KHR_external_fence") // 114
    VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR              = 1000113000,

    //@extension("VK_KHR_external_fence_win32") // 115
    VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR        = 1000114000,
    VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR        = 1000114001,
    VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR           = 1000114002,

    //@extension("VK_KHR_external_fence_fd") // 117
    VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR                  = 1000115000,
    VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR                     = 1000115001,

    //@extension("VK_KHR_maintenance2") // 118
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR             = 1000117000,
    VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR       = 1000117001,
    VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR                          = 1000117002,
    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = 1000117003,

    //@extension("VK_KHR_get_surface_capabilities2") // 120
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR        = 1000119000,
    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR                = 1000119001,
    VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR                      = 1000119002,

    //@extension("VK_KHR_variable_pointers") // 121
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = 1000120000,

    //@extension("VK_KHR_display_properties2") // 122
    VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR                  = 1000121000,
    VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR            = 1000121001,
    VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR             = 1000121002,
    VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR                  = 1000121003,
    VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR          = 1000121004,

    //@extension("VK_MVK_ios_surface") // 123
    VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK               = 1000122000,

    //@extension("VK_MVK_macos_surface") // 124
    VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK             = 1000123000,

    //@extension("VK_KHR_dedicated_allocation") // 128
    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR         = 1000127000,
    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR        = 1000127001,

    //@extension("VK_EXT_debug_utils") // 129
    VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT          = 1000128000,
    VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT           = 1000128001,
    VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT                     = 1000128002,
    VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT   = 1000128003,
    VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT     = 1000128004,

    //@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
    VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID             = 1000129000,
    VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID        = 1000129001,
    VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002,
    VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID       = 1000129003,
    VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID   = 1000129004,
    VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID                           = 1000129005,

    //@extension("VK_EXT_sampler_filter_minmax") // 131
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000,
    VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001,

    //@extension("VK_EXT_inline_uniform_block") // 139
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT     = 1000138000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT   = 1000138001,
    VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT         = 1000138002,
    VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT  = 1000138003,

    //@extension("VK_EXT_sample_locations") // 144
    VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT                         = 1000143000,
    VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT       = 1000143001,
    VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT   = 1000143002,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT   = 1000143003,
    VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT                        = 1000143004,

    //@extension("VK_KHR_get_memory_requirements2") // 147
    VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR         = 1000146000,
    VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR          = 1000146001,
    VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR   = 1000146002,
    VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR                     = 1000146003,
    VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR        = 1000146004,

    //@extension("VK_KHR_image_format_list") // 148
    VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR             = 1000147000,

    //@extension("VK_EXT_blend_operation_advanced") // 149
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001,
    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002,

    //@extension("VK_NV_fragment_coverage_to_color") // 150
    VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000,

    //@extension("VK_NV_framebuffer_mixed_samples") // 153
    VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000,

    //@extension("VK_KHR_sampler_ycbcr_conversion") // 157
    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR              = 1000156000,
    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR                     = 1000156001,
    VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR                      = 1000156002,
    VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR              = 1000156003,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = 1000156004,
    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR  = 1000156005,

    //@extension("VK_EXT_image_drm_format_modifier") // 159
    VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT               = 1000158000,
    VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT                    = 1000158001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT    = 1000158002,
    VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT        = 1000158003,
    VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT    = 1000158004,
    VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT              = 1000158005,

    //@extension("VK_KHR_bind_memory2") // 158
    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR                       = 1000157000,
    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR                        = 1000157001,

    //@extension("VK_EXT_validation_cache") // 161
    VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT                  = 1000160000,
    VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT    = 1000160001,

    //@extension("VK_EXT_descriptor_indexing") // 162
    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT           = 1000161000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT              = 1000161001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT            = 1000161002,
    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT    = 1000161003,
    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT   = 1000161004,

    //@extension("VK_NV_shading_rate_image") // 165
    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002,
    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005,

    //@extension("VK_NVX_raytracing") // 166
    VK_STRUCTURE_TYPE_RAYTRACING_PIPELINE_CREATE_INFO_NVX = 1000165000,
    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NVX = 1000165001,
    VK_STRUCTURE_TYPE_GEOMETRY_INSTANCE_NVX = 1000165002,
    VK_STRUCTURE_TYPE_GEOMETRY_NVX = 1000165003,
    VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NVX = 1000165004,
    VK_STRUCTURE_TYPE_GEOMETRY_AABB_NVX = 1000165005,
    VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NVX = 1000165006,
    VK_STRUCTURE_TYPE_DESCRIPTOR_ACCELERATION_STRUCTURE_INFO_NVX = 1000165007,
    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NVX = 1000165008,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAYTRACING_PROPERTIES_NVX = 1000165009,
    VK_STRUCTURE_TYPE_HIT_SHADER_MODULE_CREATE_INFO_NVX = 1000165010,

    //@extension("VK_NV_representative_fragment_test") // 167
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000,
    VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001,

    //@extension("VK_KHR_maintenance3") // 169
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR      = 1000168000,
    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR                 = 1000168001,

    //@extension("VK_EXT_global_priority") // 175
    VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT      = 1000174000,

    //@extension("VK_KHR_8bit_storage") // 178
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR         = 1000177000,

    //@extension("VK_EXT_external_memory_host") // 179
    VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT                   = 1000178000,
    VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT                    = 1000178001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT   = 1000178002,

    //@extension("VK_KHR_shader_atomic_int64") // 181
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR  = 1000180000,

    //@extension("VK_EXT_calibrated_timestamps") // 185
    VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT                     = 1000184000,

    //@extension("VK_KHR_driver_properties") // 197
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR             = 1000196000,

    //@extension("VK_AMD_shader_core_properties") // 186
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD        = 1000185000,

    //@extension("VK_EXT_vertex_attribute_divisor") // 191
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT   = 1000190000,
    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT       = 1000190001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT     = 1000190002,

    //@extension("VK_NV_device_diagnostic_checkpoints") // 207
    VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV                        = 1000206000,
    VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV     = 1000206001,

    //@extension("VK_KHR_vulkan_memory_model") // 212
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = 1000211000,

    //@extension("VK_EXT_pci_bus_info") // 213
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT       = 1000212000,

    //@extension("VK_FUCHSIA_imagepipe_surface") // 215
    VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA     = 1000214000,
}

enum VkSubpassContents {
    VK_SUBPASS_CONTENTS_INLINE                              = 0x00000000,
    VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS           = 0x00000001,
}

enum VkPipelineCacheHeaderVersion {
    VK_PIPELINE_CACHE_HEADER_VERSION_ONE                    = 1,
}

@lastUnused(-11)
/// Error and return codes
enum VkResult {
    // Return codes for successful operation execution (positive values)
    VK_SUCCESS                                              = 0,
    VK_NOT_READY                                            = 1,
    VK_TIMEOUT                                              = 2,
    VK_EVENT_SET                                            = 3,
    VK_EVENT_RESET                                          = 4,
    VK_INCOMPLETE                                           = 5,

    //@extension("VK_KHR_swapchain") // 2
    VK_SUBOPTIMAL_KHR                                       = 1000001003,

    // Error codes (negative values)
    VK_ERROR_OUT_OF_HOST_MEMORY                             = 0xFFFFFFFF, // -1
    VK_ERROR_OUT_OF_DEVICE_MEMORY                           = 0xFFFFFFFE, // -2
    VK_ERROR_INITIALIZATION_FAILED                          = 0xFFFFFFFD, // -3
    VK_ERROR_DEVICE_LOST                                    = 0xFFFFFFFC, // -4
    VK_ERROR_MEMORY_MAP_FAILED                              = 0xFFFFFFFB, // -5
    VK_ERROR_LAYER_NOT_PRESENT                              = 0xFFFFFFFA, // -6
    VK_ERROR_EXTENSION_NOT_PRESENT                          = 0xFFFFFFF9, // -7
    VK_ERROR_FEATURE_NOT_PRESENT                            = 0xFFFFFFF8, // -8
    VK_ERROR_INCOMPATIBLE_DRIVER                            = 0xFFFFFFF7, // -9
    VK_ERROR_TOO_MANY_OBJECTS                               = 0xFFFFFFF6, // -10
    VK_ERROR_FORMAT_NOT_SUPPORTED                           = 0xFFFFFFF5, // -11
    VK_ERROR_FRAGMENTED_POOL                                = 0xFFFFFFF4, // -12

    //@vulkan1_1
    VK_ERROR_OUT_OF_POOL_MEMORY                             = 0xC4642878, // -1000069000
    VK_ERROR_INVALID_EXTERNAL_HANDLE                        = 0xC4641CBD, // -1000072003

    //@extension("VK_KHR_surface") // 1
    VK_ERROR_SURFACE_LOST_KHR                               = 0xC4653600, // -1000000000
    VK_ERROR_NATIVE_WINDOW_IN_USE_KHR                       = 0xC46535FF, // -1000000001

    //@extension("VK_KHR_swapchain") // 2
    VK_ERROR_OUT_OF_DATE_KHR                                = 0xC4653214, // -1000001004

    //@extension("VK_KHR_display_swapchain") // 4
    VK_ERROR_INCOMPATIBLE_DISPLAY_KHR                       = 0xC4652A47, // -1000003001

    //@extension("VK_EXT_debug_report") // 12
    VK_ERROR_VALIDATION_FAILED_EXT                          = 0xC4650B07, // -1000011001

    //@extension("VK_NV_glsl_shader") // 13
    VK_ERROR_INVALID_SHADER_NV                              = 0xC4650720, // -1000012000

    //@extension("VK_KHR_maintenance1") // 70
    VK_ERROR_OUT_OF_POOL_MEMORY_KHR                         = 0xC4642878, // -1000069000

    //@extension("VK_KHR_external_memory") // 73
    VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR                    = 0xC4641CBD, // -1000072003

    //@extension("VK_EXT_image_drm_format_modifier") // 159
    VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT   = 0xC462CCD0, // -1000158000

    //@extension("VK_EXT_descriptor_indexing") // 162
    VK_ERROR_FRAGMENTATION_EXT                              = 0xc462c118, // -1000161000

    //@extension("VK_EXT_global_priority") // 175
    VK_ERROR_NOT_PERMITTED_EXT                              = 0xC4628E4F, // -1000174001
}

enum VkDynamicState {
    VK_DYNAMIC_STATE_VIEWPORT                               = 0x00000000,
    VK_DYNAMIC_STATE_SCISSOR                                = 0x00000001,
    VK_DYNAMIC_STATE_LINE_WIDTH                             = 0x00000002,
    VK_DYNAMIC_STATE_DEPTH_BIAS                             = 0x00000003,
    VK_DYNAMIC_STATE_BLEND_CONSTANTS                        = 0x00000004,
    VK_DYNAMIC_STATE_DEPTH_BOUNDS                           = 0x00000005,
    VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK                   = 0x00000006,
    VK_DYNAMIC_STATE_STENCIL_WRITE_MASK                     = 0x00000007,
    VK_DYNAMIC_STATE_STENCIL_REFERENCE                      = 0x00000008,

    //@extension("VK_NV_clip_space_w_scaling") // 88
    VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV                  = 1000087000,

    //@extension("VK_EXT_discard_rectangles") // 100
    VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT                  = 1000099000,

    //@extension("VK_EXT_sample_locations") // 144
    VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT                   = 1000143000,

    //@extension("VK_NV_shading_rate_image") // 165
    VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV       = 1000164004,
    VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV        = 1000164006,

    //@extension("VK_NV_scissor_exclusive") // 206
    VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV                   = 1000205001,
}

enum VkObjectType {
    VK_OBJECT_TYPE_UNKNOWN                                  = 0,
    VK_OBJECT_TYPE_INSTANCE                                 = 1,
    VK_OBJECT_TYPE_PHYSICAL_DEVICE                          = 2,
    VK_OBJECT_TYPE_DEVICE                                   = 3,
    VK_OBJECT_TYPE_QUEUE                                    = 4,
    VK_OBJECT_TYPE_SEMAPHORE                                = 5,
    VK_OBJECT_TYPE_COMMAND_BUFFER                           = 6,
    VK_OBJECT_TYPE_FENCE                                    = 7,
    VK_OBJECT_TYPE_DEVICE_MEMORY                            = 8,
    VK_OBJECT_TYPE_BUFFER                                   = 9,
    VK_OBJECT_TYPE_IMAGE                                    = 10,
    VK_OBJECT_TYPE_EVENT                                    = 11,
    VK_OBJECT_TYPE_QUERY_POOL                               = 12,
    VK_OBJECT_TYPE_BUFFER_VIEW                              = 13,
    VK_OBJECT_TYPE_IMAGE_VIEW                               = 14,
    VK_OBJECT_TYPE_SHADER_MODULE                            = 15,
    VK_OBJECT_TYPE_PIPELINE_CACHE                           = 16,
    VK_OBJECT_TYPE_PIPELINE_LAYOUT                          = 17,
    VK_OBJECT_TYPE_RENDER_PASS                              = 18,
    VK_OBJECT_TYPE_PIPELINE                                 = 19,
    VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT                    = 20,
    VK_OBJECT_TYPE_SAMPLER                                  = 21,
    VK_OBJECT_TYPE_DESCRIPTOR_POOL                          = 22,
    VK_OBJECT_TYPE_DESCRIPTOR_SET                           = 23,
    VK_OBJECT_TYPE_FRAMEBUFFER                              = 24,
    VK_OBJECT_TYPE_COMMAND_POOL                             = 25,

    //@vulkan1_1
    VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION                 = 1000156000,
    VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE               = 1000085000,

    //@extension("VK_KHR_surface") // 1
    VK_OBJECT_TYPE_SURFACE_KHR                              = 1000000000,

    //@extension("VK_KHR_swapchain") // 2
    VK_OBJECT_TYPE_SWAPCHAIN_KHR                            = 1000001000,

    //@extension("VK_KHR_display") // 3
    VK_OBJECT_TYPE_DISPLAY_KHR                              = 1000002000,
    VK_OBJECT_TYPE_DISPLAY_MODE_KHR                         = 1000002001,

    //@extension("VK_KHR_debug_report") // 12
    VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT                = 1000011000,

    //@extension("VK_KHR_descriptor_update_template") // 86
    VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR           = 1000085000,

    //@extension("VK_NVX_device_generated_commands") // 87
    VK_OBJECT_TYPE_OBJECT_TABLE_NVX                         = 1000086000,
    VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX             = 1000086001,

    //@extension("VK_EXT_debug_utils") // 129
    VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT                = 1000128000,

    //@extension("VK_KHR_sampler_ycbcr_conversion") // 157
    VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR             = 1000156000,

    //@extension("VK_EXT_validation_cache") // 161
    VK_OBJECT_TYPE_VALIDATION_CACHE_EXT                     = 1000160000,

    //@extension("VK_NVX_raytracing") // 166
    VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NVX               = 1000165000,
}


//@vulkan1_1 enums

enum VkPointClippingBehavior {
    VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES              = 0,
    VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY        = 1,
}

enum VkTessellationDomainOrigin {
    VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT                = 0,
    VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT                = 1,
}

enum VkSamplerYcbcrModelConversion {
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY          = 0,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY        = 1,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709             = 2,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601             = 3,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020            = 4,
}

enum VkSamplerYcbcrRange {
    VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,
    VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1,
}

enum VkChromaLocation {
    VK_CHROMA_LOCATION_COSITED_EVEN = 0,
    VK_CHROMA_LOCATION_MIDPOINT = 1,
}

enum VkDescriptorUpdateTemplateType {
    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0,
    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
}

enum VkVendorId {
    VK_VENDOR_ID_VIV                                        = 0x10001,
    VK_VENDOR_ID_VSI                                        = 0x10002,
    VK_VENDOR_ID_KAZAN                                      = 0x10003,
}

@extension("VK_KHR_surface") // 1
enum VkPresentModeKHR {
    VK_PRESENT_MODE_IMMEDIATE_KHR                           = 0x00000000,
    VK_PRESENT_MODE_MAILBOX_KHR                             = 0x00000001,
    VK_PRESENT_MODE_FIFO_KHR                                = 0x00000002,
    VK_PRESENT_MODE_FIFO_RELAXED_KHR                        = 0x00000003,

    //@extension("VK_KHR_shared_presentable_image") // 112
    VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR               = 1000111000,
    VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR           = 1000111001,
}

@extension("VK_KHR_surface") // 1
enum VkColorSpaceKHR {
    VK_COLOR_SPACE_SRGB_NONLINEAR_KHR                       = 0x00000000,

    //@extension("VK_EXT_swapchain_colorspace") // 105
    VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT                 = 1000104001,
    VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT                 = 1000104002,
    VK_COLOR_SPACE_DCI_P3_LINEAR_EXT                        = 1000104003,
    VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT                     = 1000104004,
    VK_COLOR_SPACE_BT709_LINEAR_EXT                         = 1000104005,
    VK_COLOR_SPACE_BT709_NONLINEAR_EXT                      = 1000104006,
    VK_COLOR_SPACE_BT2020_LINEAR_EXT                        = 1000104007,
    VK_COLOR_SPACE_HDR10_ST2084_EXT                         = 1000104008,
    VK_COLOR_SPACE_DOLBYVISION_EXT                          = 1000104009,
    VK_COLOR_SPACE_HDR10_HLG_EXT                            = 1000104010,
    VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT                      = 1000104011,
    VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT                   = 1000104012,
    VK_COLOR_SPACE_PASS_THROUGH_EXT                         = 1000104013,
    VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT              = 1000104014,
}

@extension("VK_EXT_debug_report") // 12
enum VkDebugReportObjectTypeEXT {
    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT                 = 0,
    VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT                = 1,
    VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT         = 2,
    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT                  = 3,
    VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT                   = 4,
    VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT               = 5,
    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT          = 6,
    VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT                   = 7,
    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT           = 8,
    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT                  = 9,
    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT                   = 10,
    VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT                   = 11,
    VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT              = 12,
    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT             = 13,
    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT              = 14,
    VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT           = 15,
    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT          = 16,
    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT         = 17,
    VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT             = 18,
    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT                = 19,
    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT   = 20,
    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT                 = 21,
    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT         = 22,
    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT          = 23,
    VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT             = 24,
    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT            = 25,
    VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT             = 26,
    VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT           = 27,
    VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28,
    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT             = 29,
    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT        = 30,
    VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT        = 31,
    VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32,

    //extension("VK_EXT_validation_cache") // 161
    VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT    = 33,

    //extension("VK_KHR_descriptor_update_template") // 86
    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = 1000085000,

    //@extension("VK_KHR_sampler_ycbcr_conversion") // 157
    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = 1000156000,

    //@extension("VK_NVX_raytracing") // 166
    VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NVX_EXT  = 1000165000,
}

@extension("VK_AMD_rasterization_order") // 19
enum VkRasterizationOrderAMD {
    VK_RASTERIZATION_ORDER_STRICT_AMD                       = 0,
    VK_RASTERIZATION_ORDER_RELAXED_AMD                      = 1,
}

@extension("VK_AMD_shader_info") // 43
enum VkShaderInfoTypeAMD {
    VK_SHADER_INFO_TYPE_STATISTICS_AMD                      = 0,
    VK_SHADER_INFO_TYPE_BINARY_AMD                          = 1,
    VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD                     = 2,
}

@extension("VK_EXT_validation_flags") // 62
enum VkValidationCheckEXT {
    VK_VALIDATION_CHECK_ALL_EXT                             = 0,
    VK_VALIDATION_CHECK_SHADERS_EXT                         = 1,
}

@extension("VK_KHR_descriptor_update_template") // 86
enum VkDescriptorUpdateTemplateTypeKHR {
    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR   = 0,
    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
}

@extension("VK_NVX_device_generated_commands") // 87
enum VkIndirectCommandsTokenTypeNVX {
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX            = 0,
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX      = 1,
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX        = 2,
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX       = 3,
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX       = 4,
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX        = 5,
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX                = 6,
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX            = 7,
}

@extension("VK_NVX_device_generated_commands") // 87
enum VkObjectEntryTypeNVX {
    VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX                 = 0,
    VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX                       = 1,
    VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX                   = 2,
    VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX                  = 3,
    VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX                  = 4,
}

@extension("VK_EXT_display_control") // 92
enum VkDisplayPowerStateEXT {
    VK_DISPLAY_POWER_STATE_OFF_EXT                          = 0,
    VK_DISPLAY_POWER_STATE_SUSPEND_EXT                      = 1,
    VK_DISPLAY_POWER_STATE_ON_EXT                           = 2,
}

@extension("VK_EXT_display_control") // 92
enum VkDeviceEventTypeEXT {
    VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT                = 0,
}

@extension("VK_EXT_display_control") // 92
enum VkDisplayEventTypeEXT {
    VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT               = 0,
}

@extension("VK_NV_viewport_swizzle") // 99
enum VkViewportCoordinateSwizzleNV {
    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV            = 0,
    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV            = 1,
    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV            = 2,
    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV            = 3,
    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV            = 4,
    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV            = 5,
    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV            = 6,
    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV            = 7,
}

@extension("VK_EXT_discard_rectangles") // 100
enum VkDiscardRectangleModeEXT {
    VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0,
    VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1,
}

@extension("VK_EXT_conservative_rasterization") // 102
enum VkConservativeRasterizationModeEXT {
    VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT         = 0,
    VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT     = 1,
    VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT    = 2,
}

@extension("VK_KHR_maintenance2") // 118
enum VkPointClippingBehaviorKHR {
    VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR          = 0,
    VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR    = 1,
}

@extension("VK_KHR_maintenance2") // 118
enum VkTessellationDomainOriginKHR {
    VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR            = 0,
    VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR            = 1,
}

@extension("VK_EXT_sampler_filter_minmax") // 131
enum VkSamplerReductionModeEXT {
    VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT          = 0,
    VK_SAMPLER_REDUCTION_MODE_MIN_EXT                       = 1,
    VK_SAMPLER_REDUCTION_MODE_MAX_EXT                       = 2,
}

@extension("VK_EXT_blend_operation_advanced") // 149
enum VkBlendOverlapEXT {
    VK_BLEND_OVERLAP_UNCORRELATED_EXT                       = 0,
    VK_BLEND_OVERLAP_DISJOINT_EXT                           = 1,
    VK_BLEND_OVERLAP_CONJOINT_EXT                           = 2,
}

@extension("VK_NV_framebuffer_mixed_samples") // 153
enum VkCoverageModulationModeNV {
    VK_COVERAGE_MODULATION_MODE_NONE_NV                     = 0,
    VK_COVERAGE_MODULATION_MODE_RGB_NV                      = 1,
    VK_COVERAGE_MODULATION_MODE_ALPHA_NV                    = 2,
    VK_COVERAGE_MODULATION_MODE_RGBA_NV                     = 3,
}

@extension("VK_KHR_sampler_ycbcr_conversion") // 157
enum VkSamplerYcbcrModelConversionKHR {
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR      = 0,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR    = 1,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR         = 2,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR         = 3,
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR        = 4,
}

@extension("VK_KHR_sampler_ycbcr_conversion") // 157
enum VkSamplerYcbcrRangeKHR {
    VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR                     = 0,
    VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR                   = 1,
}

@extension("VK_KHR_sampler_ycbcr_conversion") // 157
enum VkChromaLocationKHR {
    VK_CHROMA_LOCATION_COSITED_EVEN_KHR                     = 0,
    VK_CHROMA_LOCATION_MIDPOINT_KHR                         = 1,
}

@extension("VK_EXT_validation_cache") // 161
enum VkValidationCacheHeaderVersionEXT {
    VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT              = 1,
}

@extension("VK_NV_shading_rate_image") // 165
enum VkShadingRatePaletteEntryNV {
    VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV                 = 0,
    VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV       = 1,
    VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV        = 2,
    VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV        = 3,
    VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV        = 4,
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV         = 5,
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV    = 6,
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV    = 7,
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV    = 8,
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV    = 9,
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV    = 10,
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV    = 11,
}

@extension("VK_NV_shading_rate_image") // 165
enum VkCoarseSampleOrderTypeNV {
    VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV                  = 0,
    VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV                   = 1,
    VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV              = 2,
    VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV             = 3,
}

@extension("VK_NVX_raytracing") // 166
enum VkGeometryTypeNVX {
    VK_GEOMETRY_TYPE_TRIANGLES_NVX                          = 0,
    VK_GEOMETRY_TYPE_AABBS_NVX                              = 1,
}

@extension("VK_NVX_raytracing") // 166
enum VkAccelerationStructureTypeNVX {
    VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NVX            = 0,
    VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NVX         = 1,
}

@extension("VK_NVX_raytracing") // 166
enum VkCopyAccelerationStructureModeNVX {
    VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NVX           = 0,
    VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NVX         = 1,
}

@extension("VK_EXT_global_priority") // 175
enum VkQueueGlobalPriorityEXT {
    VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT                        = 128,
    VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT                     = 256,
    VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT                       = 512,
    VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT                   = 1024,
}

@extension("VK_EXT_calibrated_timestamps") // 185
enum VkTimeDomainEXT {
    VK_TIME_DOMAIN_DEVICE_EXT                               = 0,
    VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT                      = 1,
    VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT                  = 2,
    VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT            = 3,
}

@extension("VK_KHR_driver_properties") // 197
enum VkDriverIdKHR {
    VK_DRIVER_ID_AMD_PROPRIETARY_KHR                        = 1,
    VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR                        = 2,
    VK_DRIVER_ID_MESA_RADV_KHR                              = 3,
    VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR                     = 4,
    VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR              = 5,
    VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR                 = 6,
    VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR                = 7,
    VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR                   = 8,
    VK_DRIVER_ID_ARM_PROPRIETARY_KHR                        = 9,
}

/////////////////
//  Bitfields  //
/////////////////

/// Queue capabilities
type VkFlags VkQueueFlags
bitfield VkQueueFlagBits {
    VK_QUEUE_GRAPHICS_BIT                                   = 0x00000001,    /// Queue supports graphics operations
    VK_QUEUE_COMPUTE_BIT                                    = 0x00000002,    /// Queue supports compute operations
    VK_QUEUE_TRANSFER_BIT                                   = 0x00000004,    /// Queue supports transfer operations
    VK_QUEUE_SPARSE_BINDING_BIT                             = 0x00000008,    /// Queue supports sparse resource memory management operations

    //@vulkan1_1
    VK_QUEUE_PROTECTED_BIT                                  = 0x00000010,
}

/// Memory properties passed into vkAllocMemory().
type VkFlags VkMemoryPropertyFlags
bitfield VkMemoryPropertyFlagBits {
    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT                     = 0x00000001,
    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT                     = 0x00000002,
    VK_MEMORY_PROPERTY_HOST_COHERENT_BIT                    = 0x00000004,
    VK_MEMORY_PROPERTY_HOST_CACHED_BIT                      = 0x00000008,
    VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT                 = 0x00000010,

    //@vulkan1_1
    VK_MEMORY_PROPERTY_PROTECTED_BIT                        = 0x00000020,
}

/// Memory heap flags
type VkFlags VkMemoryHeapFlags
bitfield VkMemoryHeapFlagBits {
    VK_MEMORY_HEAP_DEVICE_LOCAL_BIT                         = 0x00000001,

    //@vulkan1_1
    VK_MEMORY_HEAP_MULTI_INSTANCE_BIT                       = 0x00000002,

    //@extension("VK_KHR_device_group_creation") // 71
    VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR                   = 0x00000002,
}

/// Access flags
type VkFlags VkAccessFlags
bitfield VkAccessFlagBits {
    VK_ACCESS_INDIRECT_COMMAND_READ_BIT                     = 0x00000001,
    VK_ACCESS_INDEX_READ_BIT                                = 0x00000002,
    VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT                     = 0x00000004,
    VK_ACCESS_UNIFORM_READ_BIT                              = 0x00000008,
    VK_ACCESS_INPUT_ATTACHMENT_READ_BIT                     = 0x00000010,
    VK_ACCESS_SHADER_READ_BIT                               = 0x00000020,
    VK_ACCESS_SHADER_WRITE_BIT                              = 0x00000040,
    VK_ACCESS_COLOR_ATTACHMENT_READ_BIT                     = 0x00000080,
    VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT                    = 0x00000100,
    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT             = 0x00000200,
    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT            = 0x00000400,
    VK_ACCESS_TRANSFER_READ_BIT                             = 0x00000800,
    VK_ACCESS_TRANSFER_WRITE_BIT                            = 0x00001000,
    VK_ACCESS_HOST_READ_BIT                                 = 0x00002000,
    VK_ACCESS_HOST_WRITE_BIT                                = 0x00004000,
    VK_ACCESS_MEMORY_READ_BIT                               = 0x00008000,
    VK_ACCESS_MEMORY_WRITE_BIT                              = 0x00010000,

    //@extension("VK_NVX_device_generated_commands") // 87
    VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX                  = 0x00020000,
    VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX                 = 0x00040000,

    //@extension("VK_EXT_blend_operation_advanced") // 149
    VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT     = 0x00080000,

    //@extension("VK_EXT_conditional_rendering") // 82
    VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT            = 0x00100000,

    //@extension("VK_NV_shading_rate_image") // 165
    VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV                = 0x00800000,

    //@extension("VK_NVX_raytracing") // 166
    VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NVX           = 0x00200000,
    VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NVX          = 0x00400000,

    //@extension("VK_EXT_transform_feedback") // 29
    VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT              = 0x02000000,
    VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT       = 0x04000000,
    VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT      = 0x08000000,
}

/// Buffer usage flags
type VkFlags VkBufferUsageFlags
bitfield VkBufferUsageFlagBits {
    VK_BUFFER_USAGE_TRANSFER_SRC_BIT                        = 0x00000001,    /// Can be used as a source of transfer operations
    VK_BUFFER_USAGE_TRANSFER_DST_BIT                        = 0x00000002,    /// Can be used as a destination of transfer operations
    VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT                = 0x00000004,    /// Can be used as TBO
    VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT                = 0x00000008,    /// Can be used as IBO
    VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT                      = 0x00000010,    /// Can be used as UBO
    VK_BUFFER_USAGE_STORAGE_BUFFER_BIT                      = 0x00000020,    /// Can be used as SSBO
    VK_BUFFER_USAGE_INDEX_BUFFER_BIT                        = 0x00000040,    /// Can be used as source of fixed function index fetch (index buffer)
    VK_BUFFER_USAGE_VERTEX_BUFFER_BIT                       = 0x00000080,    /// Can be used as source of fixed function vertex fetch (VBO)
    VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT                     = 0x00000100,    /// Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)

    //@extension("VK_EXT_conditional_rendering") // 82
    VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT           = 0x00000200,

    //@extension("VK_NVX_raytracing") // 166
    VK_BUFFER_USAGE_RAYTRACING_BIT_NVX                      = 0x00000400,

    //@extension("VK_EXT_transform_feedback") // 29
    VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT           = 0x00000800,
    VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT   = 0x00001000,
}

/// Buffer creation flags
type VkFlags VkBufferCreateFlags
bitfield VkBufferCreateFlagBits {
    VK_BUFFER_CREATE_SPARSE_BINDING_BIT                     = 0x00000001,    /// Buffer should support sparse backing
    VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT                   = 0x00000002,    /// Buffer should support sparse backing with partial residency
    VK_BUFFER_CREATE_SPARSE_ALIASED_BIT                     = 0x00000004,    /// Buffer should support constent data access to physical memory blocks mapped into multiple locations of sparse buffers

    //@vulkan1_1
    VK_BUFFER_CREATE_PROTECTED_BIT                          = 0x00000008,
}

/// Shader stage flags
type VkFlags VkShaderStageFlags
bitfield VkShaderStageFlagBits {
    VK_SHADER_STAGE_VERTEX_BIT                              = 0x00000001,
    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT                = 0x00000002,
    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT             = 0x00000004,
    VK_SHADER_STAGE_GEOMETRY_BIT                            = 0x00000008,
    VK_SHADER_STAGE_FRAGMENT_BIT                            = 0x00000010,
    VK_SHADER_STAGE_COMPUTE_BIT                             = 0x00000020,
    VK_SHADER_STAGE_ALL_GRAPHICS                            = 0x0000001F,

    VK_SHADER_STAGE_ALL                                     = 0x7FFFFFFF,

    //@extension("VK_NVX_raytracing") // 166
    VK_SHADER_STAGE_RAYGEN_BIT_NVX                          = 0x00000100,
    VK_SHADER_STAGE_ANY_HIT_BIT_NVX                         = 0x00000200,
    VK_SHADER_STAGE_CLOSEST_HIT_BIT_NVX                     = 0x00000400,
    VK_SHADER_STAGE_MISS_BIT_NVX                            = 0x00000800,
    VK_SHADER_STAGE_INTERSECTION_BIT_NVX                    = 0x00001000,
    VK_SHADER_STAGE_CALLABLE_BIT_NVX                        = 0x00002000,

    //@extension("VK_NV_mesh_shader") // 203
    VK_SHADER_STAGE_TASK_BIT_NV                             = 0x00000040,
    VK_SHADER_STAGE_MESH_BIT_NV                             = 0x00000080,
}

/// Descriptor pool create flags
type VkFlags VkDescriptorPoolCreateFlags
bitfield VkDescriptorPoolCreateFlagBits {
    VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT       = 0x00000001,

    //@extension("VK_EXT_descriptor_indexing") // 162
    VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT     = 0x00000002,
}

/// Descriptor pool reset flags
type VkFlags VkDescriptorPoolResetFlags
//bitfield VkDescriptorPoolResetFlagBits {
//}

/// Image usage flags
type VkFlags VkImageUsageFlags
bitfield VkImageUsageFlagBits {
    VK_IMAGE_USAGE_TRANSFER_SRC_BIT                         = 0x00000001,    /// Can be used as a source of transfer operations
    VK_IMAGE_USAGE_TRANSFER_DST_BIT                         = 0x00000002,    /// Can be used as a destination of transfer operations
    VK_IMAGE_USAGE_SAMPLED_BIT                              = 0x00000004,    /// Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
    VK_IMAGE_USAGE_STORAGE_BIT                              = 0x00000008,    /// Can be used as storage image (STORAGE_IMAGE descriptor type)
    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                     = 0x00000010,    /// Can be used as framebuffer color attachment
    VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT             = 0x00000020,    /// Can be used as framebuffer depth/stencil attachment
    VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT                 = 0x00000040,    /// Image data not needed outside of rendering
    VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT                     = 0x00000080,    /// Can be used as framebuffer input attachment

    //@extension("VK_NV_shading_rate_image") // 165
    VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV                = 0x00000100,
}

/// Image creation flags
type VkFlags VkImageCreateFlags
bitfield VkImageCreateFlagBits {
    VK_IMAGE_CREATE_SPARSE_BINDING_BIT                      = 0x00000001,    /// Image should support sparse backing
    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT                    = 0x00000002,    /// Image should support sparse backing with partial residency
    VK_IMAGE_CREATE_SPARSE_ALIASED_BIT                      = 0x00000004,    /// Image should support constent data access to physical memory blocks mapped into multiple locations of sparse images
    VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT                      = 0x00000008,    /// Allows image views to have different format than the base image
    VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT                     = 0x00000010,    /// Allows creating image views with cube type from the created image

    //@vulkan1_1
    VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT                 = 0x00000020,
    VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT         = 0x00000040,
    VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT         = 0x00000080,
    VK_IMAGE_CREATE_EXTENDED_USAGE_BIT                      = 0x00000100,
    VK_IMAGE_CREATE_DISJOINT_BIT                            = 0x00000200,
    VK_IMAGE_CREATE_ALIAS_BIT                               = 0x00000400,
    VK_IMAGE_CREATE_PROTECTED_BIT                           = 0x00000800,

    //@extension("VK_KHR_maintenance1") // 70
    VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR             = 0x00000020,

    //@extension("VK_KHR_device_group") // 61
    VK_IMAGE_CREATE_BIND_SFR_BIT_KHR                        = 0x00000040,

    //@extension("VK_KHR_maintenance2") // 118
    VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR     = 0x00000080,
    VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR                  = 0x00000100,

    //@extension("VK_KHR_sampler_ycbcr_conversion") // 157
    VK_IMAGE_CREATE_DISJOINT_BIT_KHR                        = 0x00000200,

    //@extension("VK_KHR_bind_memory2") // 158
    VK_IMAGE_CREATE_ALIAS_BIT_KHR                           = 0x00000400,

    //@extension("VK_EXT_sample_locations") // 144
    VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000,

    //@extension("VK_NV_corner_sampled_image") // 51
    VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV                   = 0x00002000,
}

/// Image view creation flags
type VkFlags VkImageViewCreateFlags
//bitfield VkImageViewCreateFlagBits {
//}

/// Pipeline creation flags
type VkFlags VkPipelineCreateFlags
bitfield VkPipelineCreateFlagBits {
    VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT             = 0x00000001,
    VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT                = 0x00000002,
    VK_PIPELINE_CREATE_DERIVATIVE_BIT                       = 0x00000004,

    //@vulkan1_1
    VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT     = 0x00000008,
    VK_PIPELINE_CREATE_DISPATCH_BASE                        = 0x00000010,

    //@extension("VK_KHR_device_group") // 61
    VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = 0x00000008,
    VK_PIPELINE_CREATE_DISPATCH_BASE_KHR                    = 0x00000010,

    //@extension("VK_NVX_raytracing") // 166
    VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NVX                = 0x00000020,
}

/// Color component flags
type VkFlags VkColorComponentFlags
bitfield VkColorComponentFlagBits {
    VK_COLOR_COMPONENT_R_BIT                                = 0x00000001,
    VK_COLOR_COMPONENT_G_BIT                                = 0x00000002,
    VK_COLOR_COMPONENT_B_BIT                                = 0x00000004,
    VK_COLOR_COMPONENT_A_BIT                                = 0x00000008,
}

/// Fence creation flags
type VkFlags VkFenceCreateFlags
bitfield VkFenceCreateFlagBits {
    VK_FENCE_CREATE_SIGNALED_BIT                            = 0x00000001,
}

/// Semaphore creation flags
type VkFlags VkSemaphoreCreateFlags
//bitfield VkSemaphoreCreateFlagBits {
//}

/// Format capability flags
type VkFlags VkFormatFeatureFlags
bitfield VkFormatFeatureFlagBits {
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT                     = 0x00000001,    /// Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
    VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT                     = 0x00000002,    /// Format can be used for storage images (STORAGE_IMAGE descriptor type)
    VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT              = 0x00000004,    /// Format supports atomic operations in case it's used for storage images
    VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT              = 0x00000008,    /// Format can be used for uniform texel buffers (TBOs)
    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT              = 0x00000010,    /// Format can be used for storage texel buffers (IBOs)
    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT       = 0x00000020,    /// Format supports atomic operations in case it's used for storage texel buffers
    VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT                     = 0x00000040,    /// Format can be used for vertex buffers (VBOs)
    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT                  = 0x00000080,    /// Format can be used for color attachment images
    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT            = 0x00000100,    /// Format supports blending in case it's used for color attachment images
    VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT          = 0x00000200,    /// Format can be used for depth/stencil attachment images
    VK_FORMAT_FEATURE_BLIT_SRC_BIT                          = 0x00000400,    /// Format can be used as the source image of blits with vkCommandBlitImage
    VK_FORMAT_FEATURE_BLIT_DST_BIT                          = 0x00000800,    /// Format can be used as the destination image of blits with vkCommandBlitImage
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT       = 0x00001000,

    //@vulkan1_1
    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT                      = 0x00004000,
    VK_FORMAT_FEATURE_TRANSFER_DST_BIT                      = 0x00008000,
    VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT                                                   = 0x00020000,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT                              = 0x00040000,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT             = 0x00080000,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT             = 0x00100000,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT   = 0x00200000,
    VK_FORMAT_FEATURE_DISJOINT_BIT                                                                  = 0x00400000,
    VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT                                                    = 0x00800000,

    //@extension("VK_IMG_filter_cubic") // 16
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG    = 0x00002000,

    //@extension("VK_KHR_maintenance1") // 70
    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR                  = 0x00004000,
    VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR                  = 0x00008000,

    //@extension("VK_EXT_sampler_filter_minmax") // 131
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT   = 0x00010000,

    //@extension("VK_KHR_sampler_ycbcr_conversion") // 157
    VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR                                                   = 0x00020000,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR                              = 0x00040000,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR             = 0x00080000,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR             = 0x00100000,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR   = 0x00200000,
    VK_FORMAT_FEATURE_DISJOINT_BIT_KHR                                                                  = 0x00400000,
    VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR                                                    = 0x00800000,
}

/// Query control flags
type VkFlags VkQueryControlFlags
bitfield VkQueryControlFlagBits {
    VK_QUERY_CONTROL_PRECISE_BIT                            = 0x00000001,
}

/// Query result flags
type VkFlags VkQueryResultFlags
bitfield VkQueryResultFlagBits {
    VK_QUERY_RESULT_64_BIT                                  = 0x00000001,   /// Results of the queries are written to the destination buffer as 64-bit values
    VK_QUERY_RESULT_WAIT_BIT                                = 0x00000002,   /// Results of the queries are waited on before proceeding with the result copy
    VK_QUERY_RESULT_WITH_AVAILABILITY_BIT                   = 0x00000004,   /// Besides the results of the query, the availability of the results is also written
    VK_QUERY_RESULT_PARTIAL_BIT                             = 0x00000008,   /// Copy the partial results of the query even if the final results aren't available
}

/// Shader module creation flags
type VkFlags VkShaderModuleCreateFlags
//bitfield VkShaderModuleCreateFlagBits {
//}

/// Event creation flags
type VkFlags VkEventCreateFlags
//bitfield VkEventCreateFlagBits {
//}

/// Command buffer usage flags
type VkFlags VkCommandBufferUsageFlags
bitfield VkCommandBufferUsageFlagBits {
    VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT             = 0x00000001,
    VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT        = 0x00000002,
    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT            = 0x00000004,
}

/// Pipeline statistics flags
type VkFlags VkQueryPipelineStatisticFlags
bitfield VkQueryPipelineStatisticFlagBits {
    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT                     = 0x00000001,  /// Optional
    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT                   = 0x00000002,  /// Optional
    VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT                   = 0x00000004,  /// Optional
    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT                 = 0x00000008,  /// Optional
    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT                  = 0x00000010,  /// Optional
    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT                        = 0x00000020,  /// Optional
    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT                         = 0x00000040,  /// Optional
    VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT                 = 0x00000080,  /// Optional
    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT         = 0x00000100,  /// Optional
    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT  = 0x00000200,  /// Optional
    VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT                  = 0x00000400,  /// Optional
}

/// Memory mapping flags
type VkFlags VkMemoryMapFlags
//bitfield VkMemoryMapFlagBits {
//}

/// Bitfield of image aspects
type VkFlags VkImageAspectFlags
bitfield VkImageAspectFlagBits {
    VK_IMAGE_ASPECT_COLOR_BIT                               = 0x00000001,
    VK_IMAGE_ASPECT_DEPTH_BIT                               = 0x00000002,
    VK_IMAGE_ASPECT_STENCIL_BIT                             = 0x00000004,
    VK_IMAGE_ASPECT_METADATA_BIT                            = 0x00000008,

    //@vulkan1_1
    VK_IMAGE_ASPECT_PLANE_0_BIT                             = 0x00000010,
    VK_IMAGE_ASPECT_PLANE_1_BIT                             = 0x00000020,
    VK_IMAGE_ASPECT_PLANE_2_BIT                             = 0x00000040,

    //@extension("VK_KHR_sampler_ycbcr_conversion") // 157
    VK_IMAGE_ASPECT_PLANE_0_BIT_KHR                         = 0x00000010,
    VK_IMAGE_ASPECT_PLANE_1_BIT_KHR                         = 0x00000020,
    VK_IMAGE_ASPECT_PLANE_2_BIT_KHR                         = 0x00000040,

    //@extension("VK_EXT_transform_feedback") // 29
    VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT                  = 0x00000080,
    VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT                  = 0x00000100,
    VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT                  = 0x00000200,
    VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT                  = 0x00000400,
}

/// Sparse memory bind flags
type VkFlags VkSparseMemoryBindFlags
bitfield VkSparseMemoryBindFlagBits {
    VK_SPARSE_MEMORY_BIND_METADATA_BIT                      = 0x00000001,
}

/// Sparse image memory requirements flags
type VkFlags VkSparseImageFormatFlags
bitfield VkSparseImageFormatFlagBits {
    VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT                  = 0x00000001,  /// Image uses a single miptail region for all array slices
    VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT                = 0x00000002,  /// Image requires mip levels to be an exact multiple of the sparse iamge block size for non-mip-tail levels.
    VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT          = 0x00000004,  /// Image uses a non-standard sparse block size
}

/// Pipeline stages
type VkFlags VkPipelineStageFlags
bitfield VkPipelineStageFlagBits {
    VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT                       = 0x00000001,  /// Before subsequent commands are processed
    VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT                     = 0x00000002,  /// Draw/DispatchIndirect command fetch
    VK_PIPELINE_STAGE_VERTEX_INPUT_BIT                      = 0x00000004,  /// Vertex/index fetch
    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT                     = 0x00000008,  /// Vertex shading
    VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT       = 0x00000010,  /// Tessellation control shading
    VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT    = 0x00000020,  /// Tessellation evaluation shading
    VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT                   = 0x00000040,  /// Geometry shading
    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT                   = 0x00000080,  /// Fragment shading
    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT              = 0x00000100,  /// Early fragment (depth/stencil) tests
    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT               = 0x00000200,  /// Late fragment (depth/stencil) tests
    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT           = 0x00000400,  /// Color attachment writes
    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT                    = 0x00000800,  /// Compute shading
    VK_PIPELINE_STAGE_TRANSFER_BIT                          = 0x00001000,  /// Transfer/copy operations
    VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT                    = 0x00002000,
    VK_PIPELINE_STAGE_HOST_BIT                              = 0x00004000,  /// Indicates host (CPU) is a source/sink of the dependency

    VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT                      = 0x00008000,  /// All stages of the graphics pipeline
    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT                      = 0x00010000,  /// All graphics, compute, copy, and transition commands

    //@extension("VK_NVX_device_generated_commands") // 87
    VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX               = 0x00020000,

    //@extension("VK_EXT_conditional_rendering") // 82
    VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT         = 0x00040000,

    //@extension("VK_NV_shading_rate_image") // 165
    VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV             = 0x00400000,

    //@extension("VK_NVX_raytracing") // 166
    VK_PIPELINE_STAGE_RAYTRACING_BIT_NVX                    = 0x00200000,

    //@extension("VK_NV_mesh_shader") // 203
    VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV                    = 0x00080000,
    VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV                    = 0x00100000,

    //@extension("VK_EXT_transform_feedback") // 29
    VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT            = 0x01000000,
}

/// Render pass attachment description flags
type VkFlags VkAttachmentDescriptionFlags
bitfield VkAttachmentDescriptionFlagBits {
    VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT                 = 0x00000001,  /// The attachment may alias physical memory of another attachment in the same renderpass
}

/// Subpass description flags
type VkFlags VkSubpassDescriptionFlags
bitfield VkSubpassDescriptionFlagBits {
    //@extension("VK_NVX_multiview_per_view_attributes") // 98
    VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX      = 0x00000001,
    VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
}

/// Command pool creation flags
type VkFlags VkCommandPoolCreateFlags
bitfield VkCommandPoolCreateFlagBits {
    VK_COMMAND_POOL_CREATE_TRANSIENT_BIT                    = 0x00000001,  /// Command buffers have a short lifetime
    VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT         = 0x00000002,  /// Command buffers may release their memory individually

    //@vulkan1_1
    VK_COMMAND_POOL_CREATE_PROTECTED_BIT                    = 0x00000004,
}

/// Command pool reset flags
type VkFlags VkCommandPoolResetFlags
bitfield VkCommandPoolResetFlagBits {
    VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT             = 0x00000001,  /// Release resources owned by the pool
}

type VkFlags VkCommandBufferResetFlags
bitfield VkCommandBufferResetFlagBits {
    VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT           = 0x00000001,  /// Release resources owned by the buffer
}

type VkFlags VkSampleCountFlags
bitfield VkSampleCountFlagBits {
    VK_SAMPLE_COUNT_1_BIT                                   = 0x00000001,
    VK_SAMPLE_COUNT_2_BIT                                   = 0x00000002,
    VK_SAMPLE_COUNT_4_BIT                                   = 0x00000004,
    VK_SAMPLE_COUNT_8_BIT                                   = 0x00000008,
    VK_SAMPLE_COUNT_16_BIT                                  = 0x00000010,
    VK_SAMPLE_COUNT_32_BIT                                  = 0x00000020,
    VK_SAMPLE_COUNT_64_BIT                                  = 0x00000040,
}

type VkFlags VkStencilFaceFlags
bitfield VkStencilFaceFlagBits {
    VK_STENCIL_FACE_FRONT_BIT                               = 0x00000001,   /// Front face
    VK_STENCIL_FACE_BACK_BIT                                = 0x00000002,   /// Back face
    VK_STENCIL_FRONT_AND_BACK                               = 0x00000003,
}

/// Instance creation flags
type VkFlags VkInstanceCreateFlags
//bitfield VkInstanceCreateFlagBits {
//}

/// Device creation flags
type VkFlags VkDeviceCreateFlags
//bitfield VkDeviceCreateFlagBits {
//}

/// Device queue creation flags
type VkFlags VkDeviceQueueCreateFlags
@vulkan1_1
bitfield VkDeviceQueueCreateFlagBits {
    VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT                    = 0x00000001,
}

/// Query pool creation flags
type VkFlags VkQueryPoolCreateFlags
//bitfield VkQueryPoolCreateFlagBits {
//}

/// Buffer view creation flags
type VkFlags VkBufferViewCreateFlags
//bitfield VkBufferViewCreateFlagBits {
//}

/// Pipeline cache creation flags
type VkFlags VkPipelineCacheCreateFlags
//bitfield VkPipelineCacheCreateFlagBits {
//}

/// Pipeline shader stage creation flags
type VkFlags VkPipelineShaderStageCreateFlags
//bitfield VkPipelineShaderStageCreateFlagBits {
//}

/// Descriptor set layout creation flags
type VkFlags VkDescriptorSetLayoutCreateFlags
bitfield VkDescriptorSetLayoutCreateFlagBits {
    //@extension("VK_KHR_push_descriptor") // 81
    VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR     = 0x00000001,

    //@extension("VK_EXT_descriptor_indexing") // 162
    VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT  = 0x00000002,
}

/// Pipeline vertex input state creation flags
type VkFlags VkPipelineVertexInputStateCreateFlags
//bitfield VkPipelineVertexInputStateCreateFlagBits {
//}

/// Pipeline input assembly state creation flags
type VkFlags VkPipelineInputAssemblyStateCreateFlags
//bitfield VkPipelineInputAssemblyStateCreateFlagBits {
//}

/// Tessellation state creation flags
type VkFlags VkPipelineTessellationStateCreateFlags
//bitfield VkPipelineTessellationStateCreateFlagBits {
//}

/// Viewport state creation flags
type VkFlags VkPipelineViewportStateCreateFlags
//bitfield VkPipelineViewportStateCreateFlagBits {
//}

/// Rasterization state creation flags
type VkFlags VkPipelineRasterizationStateCreateFlags
//bitfield VkPipelineRasterizationStateCreateFlagBits {
//}

/// Multisample state creation flags
type VkFlags VkPipelineMultisampleStateCreateFlags
//bitfield VkPipelineMultisampleStateCreateFlagBits {
//}

/// Color blend state creation flags
type VkFlags VkPipelineColorBlendStateCreateFlags
//bitfield VkPipelineColorBlendStateCreateFlagBits {
//}

/// Depth/stencil state creation flags
type VkFlags VkPipelineDepthStencilStateCreateFlags
//bitfield VkPipelineDepthStencilStateCreateFlagBits {
//}

/// Dynamic state creation flags
type VkFlags VkPipelineDynamicStateCreateFlags
//bitfield VkPipelineDynamicStateCreateFlagBits {
//}

/// Pipeline layout creation flags
type VkFlags VkPipelineLayoutCreateFlags
//bitfield VkPipelineLayoutCreateFlagBits {
//}

/// Sampler creation flags
type VkFlags VkSamplerCreateFlags
//bitfield VkSamplerCreateFlagBits {
//}

/// Render pass creation flags
type VkFlags VkRenderPassCreateFlags
//bitfield VkRenderPassCreateFlagBits {
//}

/// Framebuffer creation flags
type VkFlags VkFramebufferCreateFlags
//bitfield VkFramebufferCreateFlagBits {
//}

/// Dependency flags
type VkFlags VkDependencyFlags
bitfield VkDependencyFlagBits {
    VK_DEPENDENCY_BY_REGION_BIT                             = 0x00000001,

    //@vulkan1_1
    VK_DEPENDENCY_DEVICE_GROUP_BIT                          = 0x00000004,
    VK_DEPENDENCY_VIEW_LOCAL_BIT                            = 0x00000002,

    //@extension("VK_KHR_multiview") // 54
    VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR                        = 0x00000002,

    //@extension("VK_KHR_device_group") // 61
    VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR                      = 0x00000004,
}

/// Cull mode flags
type VkFlags VkCullModeFlags
bitfield VkCullModeFlagBits {
    VK_CULL_MODE_NONE                                       = 0x00000000,
    VK_CULL_MODE_FRONT_BIT                                  = 0x00000001,
    VK_CULL_MODE_BACK_BIT                                   = 0x00000002,
    VK_CULL_MODE_FRONT_AND_BACK                             = 0x00000003,
}

//@vulkan1_1 flags

/// Subgroup feature flags
type VkFlags VkSubgroupFeatureFlags
bitfield VkSubgroupFeatureFlagBits {
    VK_SUBGROUP_FEATURE_BASIC_BIT                           = 0x00000001,
    VK_SUBGROUP_FEATURE_VOTE_BIT                            = 0x00000002,
    VK_SUBGROUP_FEATURE_ARITHMETIC_BIT                      = 0x00000004,
    VK_SUBGROUP_FEATURE_BALLOT_BIT                          = 0x00000008,
    VK_SUBGROUP_FEATURE_SHUFFLE_BIT                         = 0x00000010,
    VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT                = 0x00000020,
    VK_SUBGROUP_FEATURE_CLUSTERED_BIT                       = 0x00000040,
    VK_SUBGROUP_FEATURE_QUAD_BIT                            = 0x00000080,

    //@extension("VK_NV_shader_subgroup_partitioned") // 199
    VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV                  = 0x00000100,
}

/// Peer memory feature flags
type VkFlags VkPeerMemoryFeatureFlags
bitfield VkPeerMemoryFeatureFlagBits {
    VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT                     = 0x00000001,
    VK_PEER_MEMORY_FEATURE_COPY_DST_BIT                     = 0x00000002,
    VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT                  = 0x00000004,
    VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT                  = 0x00000008,
}

/// Memory allocation flags
type VkFlags VkMemoryAllocateFlags
bitfield VkMemoryAllocateFlagBits {
    VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT                      = 0x00000001,
}

type VkFlags VkCommandPoolTrimFlags
//bitfield VkCommandPoolTrimFlagBits {
//}

type VkFlags VkDescriptorUpdateTemplateCreateFlags
//bitfield VkDescriptorUpdateTemplateCreateFlagBits {
//}

/// External memory handle type flags
type VkFlags VkExternalMemoryHandleTypeFlags
bitfield VkExternalMemoryHandleTypeFlagBits {
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT            = 0x00000001,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT         = 0x00000002,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT     = 0x00000004,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT        = 0x00000008,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT    = 0x00000010,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT           = 0x00000020,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT       = 0x00000040,

    //@extension("VK_EXT_external_memory_host") // 179
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT              = 0x00000080,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT   = 0x00000100,

    //@extension("VK_EXT_external_memory_dma_buf") // 126
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT                      = 0x00000200,

    //@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID  = 0x00000400,
}

/// External memory feature flags
type VkFlags VkExternalMemoryFeatureFlags
bitfield VkExternalMemoryFeatureFlagBits {
    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT           = 0x00000001,
    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT               = 0x00000002,
    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT               = 0x00000004,
}

/// External fence handle type flags
type VkFlags VkExternalFenceHandleTypeFlags
bitfield VkExternalFenceHandleTypeFlagBits {
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT             = 0x00000001,
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT          = 0x00000002,
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT      = 0x00000004,
    VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT               = 0x00000008,
}

/// External fence feature flags
type VkFlags VkExternalFenceFeatureFlags
bitfield VkExternalFenceFeatureFlagBits {
    VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT                = 0x00000001,
    VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT                = 0x00000002,
}

/// Fence import flags
type VkFlags VkFenceImportFlags
bitfield VkFenceImportFlagBits {
    VK_FENCE_IMPORT_TEMPORARY_BIT                           = 0x00000001,
}

/// Semaphore import flags
type VkFlags VkSemaphoreImportFlags
bitfield VkSemaphoreImportFlagBits {
    VK_SEMAPHORE_IMPORT_TEMPORARY_BIT                       = 0x00000001,
}

/// External semaphore handle type flags
type VkFlags VkExternalSemaphoreHandleTypeFlags
bitfield VkExternalSemaphoreHandleTypeFlagBits {
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT         = 0x00000001,
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT      = 0x00000002,
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT  = 0x00000004,
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT       = 0x00000008,
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT           = 0x00000010,
}

/// External semaphore feature flags
type VkFlags VkExternalSemaphoreFeatureFlags
bitfield VkExternalSemaphoreFeatureFlagBits {
    VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT            = 0x00000001,
    VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT            = 0x00000002,
}

@extension("VK_KHR_surface") // 1
type VkFlags VkSurfaceTransformFlagsKHR
@extension("VK_KHR_surface") // 1
bitfield VkSurfaceTransformFlagBitsKHR {
    VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR                       = 0x00000001,
    VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR                      = 0x00000002,
    VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR                     = 0x00000004,
    VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR                     = 0x00000008,
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR              = 0x00000010,
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR    = 0x00000020,
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR   = 0x00000040,
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR   = 0x00000080,
    VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR                        = 0x00000100,
}

@extension("VK_KHR_surface") // 1
type VkFlags VkCompositeAlphaFlagsKHR
@extension("VK_KHR_surface") // 1
bitfield VkCompositeAlphaFlagBitsKHR {
    VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR                       = 0x00000001,
    VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR               = 0x00000002,
    VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR              = 0x00000004,
    VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR                      = 0x00000008,
}

@extension("VK_KHR_swapchain") // 2
type VkFlags VkSwapchainCreateFlagsKHR
@extension("VK_KHR_swapchain") // 2
bitfield VkSwapchainCreateFlagBitsKHR {
    //@vulkan1_1
    VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001,
    VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR                   = 0x00000002,
}

@vulkan1_1
@extension("VK_KHR_swapchain") // 2
type VkFlags VkDeviceGroupPresentModeFlagsKHR
@vulkan1_1
@extension("VK_KHR_swapchain") // 2
bitfield VkDeviceGroupPresentModeFlagBitsKHR {
    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR              = 0x00000001,
    VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR             = 0x00000002,
    VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR                = 0x00000004,
    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008,
}

@extension("VK_KHR_display") // 3
type VkFlags VkDisplayPlaneAlphaFlagsKHR
@extension("VK_KHR_display") // 3
bitfield VkDisplayPlaneAlphaFlagBitsKHR {
    VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR                   = 0x00000001,
    VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR                   = 0x00000002,
    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR                = 0x00000004,
    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR  = 0x00000008,
}

@extension("VK_KHR_display") // 3
type VkFlags VkDisplaySurfaceCreateFlagsKHR
//@extension("VK_KHR_display") // 3
//bitfield VkDisplaySurfaceCreateFlagBitsKHR {
//}

@extension("VK_KHR_display") // 3
type VkFlags VkDisplayModeCreateFlagsKHR
//@extension("VK_KHR_display") // 3
//bitfield VkDisplayModeCreateFlagBitsKHR {
//}

@extension("VK_KHR_xlib_surface") // 5
type VkFlags VkXlibSurfaceCreateFlagsKHR
//@extension("VK_KHR_xlib_surface") // 5
//bitfield VkXlibSurfaceCreateFlagBitsKHR {
//}

@extension("VK_KHR_xcb_surface") // 6
type VkFlags VkXcbSurfaceCreateFlagsKHR
//@extension("VK_KHR_xcb_surface") // 6
//bitfield VkXcbSurfaceCreateFlagBitsKHR {
//}

@extension("VK_KHR_wayland_surface") // 7
type VkFlags VkWaylandSurfaceCreateFlagsKHR
//@extension("VK_KHR_wayland_surface") // 7
//bitfield VkWaylandSurfaceCreateFlagBitsKHR {
//}

@extension("VK_KHR_mir_surface") // 8
type VkFlags VkMirSurfaceCreateFlagsKHR
//@extension("VK_KHR_mir_surface") // 8
//bitfield VkMirSurfaceCreateFlagBitsKHR {
//}

@extension("VK_KHR_android_surface") // 9
type VkFlags VkAndroidSurfaceCreateFlagsKHR
//@extension("VK_KHR_android_surface") // 9
//bitfield VkAndroidSurfaceCreateFlagBitsKHR {
//}

@extension("VK_KHR_win32_surface") // 10
type VkFlags VkWin32SurfaceCreateFlagsKHR
//@extension("VK_KHR_win32_surface") // 10
//bitfield VkWin32SurfaceCreateFlagBitsKHR {
//}

@extension("VK_ANDROID_native_buffer") // 11
type VkFlags VkSwapchainImageUsageFlagsANDROID
@extension("VK_ANDROID_native_buffer") // 11
bitfield VkSwapchainImageUsageFlagBitsANDROID {
    VK_SWAPCHAIN_IMAGE_USAGE_FLAGS_SHARED_BIT_ANDROID = 0x00000001,
}

@extension("VK_EXT_debug_report") // 12
type VkFlags VkDebugReportFlagsEXT
@extension("VK_EXT_debug_report") // 12
bitfield VkDebugReportFlagBitsEXT {
    VK_DEBUG_REPORT_INFORMATION_BIT_EXT                     = 0x00000001,
    VK_DEBUG_REPORT_WARNING_BIT_EXT                         = 0x00000002,
    VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT             = 0x00000004,
    VK_DEBUG_REPORT_ERROR_BIT_EXT                           = 0x00000008,
    VK_DEBUG_REPORT_DEBUG_BIT_EXT                           = 0x00000010,
}

@extension("VK_EXT_transform_feedback") // 29
type VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT
//@extension("VK_EXT_transform_feedback") // 29
//bitfield VkPipelineRasterizationStateStreamCreateFlagBitsEXT {
//}

@extension("VK_NV_external_memory_capabilities") // 56
type VkFlags VkExternalMemoryHandleTypeFlagsNV
@extension("VK_NV_external_memory_capabilities") // 56
bitfield VkExternalMemoryHandleTypeFlagBitsNV {
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV      = 0x00000001,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV  = 0x00000002,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV       = 0x00000004,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV   = 0x00000008,
}

@extension("VK_NV_external_memory_capabilities") // 56
type VkFlags VkExternalMemoryFeatureFlagsNV
@extension("VK_NV_external_memory_capabilities") // 56
bitfield VkExternalMemoryFeatureFlagBitsNV {
    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV        = 0x00000001,
    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV            = 0x00000002,
    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV            = 0x00000004,
}

@extension("VK_KHR_device_group") // 61
type VkFlags VkPeerMemoryFeatureFlagsKHR
@extension("VK_KHR_device_group") // 61
bitfield VkPeerMemoryFeatureFlagBitsKHR {
    VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR                 = 0x00000001,
    VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR                 = 0x00000002,
    VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR              = 0x00000004,
    VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR              = 0x00000008,
}

@extension("VK_KHR_device_group") // 61
type VkFlags VkMemoryAllocateFlagsKHR
@extension("VK_KHR_device_group") // 61
bitfield VkMemoryAllocateFlagBitsKHR {
    VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR                  = 0x00000001,
}

@extension("VK_NN_vi_surface") // 63
type VkFlags VkViSurfaceCreateFlagsNN
//@extension("VK_NN_vi_surface") // 63
//bitfield VkViSurfaceCreateFlagBitsNN {
//}

@extension("VK_KHR_maintenance1") // 70
type VkFlags VkCommandPoolTrimFlagsKHR
//@extension("VK_KHR_maintenance1") // 70
//bitfield VkCommandPoolTrimFlagBitsKHR {
//}

@extension("VK_KHR_external_memory_capabilities") // 72
type VkFlags VkExternalMemoryHandleTypeFlagsKHR
@extension("VK_KHR_external_memory_capabilities") // 72
bitfield VkExternalMemoryHandleTypeFlagBitsKHR {
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR            = 0x00000001,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR         = 0x00000002,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR     = 0x00000004,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR        = 0x00000008,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR    = 0x00000010,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR           = 0x00000020,
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR       = 0x00000040,
}

@extension("VK_KHR_external_memory_capabilities") // 72
type VkFlags VkExternalMemoryFeatureFlagsKHR
@extension("VK_KHR_external_memory_capabilities") // 72
bitfield VkExternalMemoryFeatureFlagBitsKHR {
    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR           = 0x00000001,
    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR               = 0x00000002,
    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR               = 0x00000004,
}

@extension("VK_KHR_external_semaphore_capabilities") // 77
type VkFlags VkExternalSemaphoreHandleTypeFlagsKHR
@extension("VK_KHR_external_semaphore_capabilities") // 77
bitfield VkExternalSemaphoreHandleTypeFlagBitsKHR {
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR         = 0x00000001
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR      = 0x00000002
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR  = 0x00000004
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR       = 0x00000008
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHR          = 0x00000010
}

@extension("VK_KHR_external_semaphore_capabilities") // 77
type VkFlags VkExternalSemaphoreFeatureFlagsKHR
@extension("VK_KHR_external_semaphore_capabilities") // 77
bitfield VkExternalSemaphoreFeatureFlagBitsKHR {
    VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR            = 0x00000001,
    VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR            = 0x00000002,
}

@extension("VK_KHR_external_semaphore") // 78
type VkFlags VkSemaphoreImportFlagsKHR
@extension("VK_KHR_external_semaphore") // 78
bitfield VkSemaphoreImportFlagBitsKHR {
    VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR                       = 0x00000001,
}

@extension("VK_EXT_conditional_rendering") // 82
type VkFlags VkConditionalRenderingFlagsEXT
@extension("VK_EXT_conditional_rendering") // 82
bitfield VkConditionalRenderingFlagBitsEXT {
    VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT                   = 0x00000001,
}

@extension("VK_KHR_descriptor_update_template") // 86
type VkFlags VkDescriptorUpdateTemplateCreateFlagsKHR
//@extension("VK_KHR_descriptor_update_template") // 86
//bitfield VkDescriptorUpdateTemplateCreateFlagBitsKHR {
//}

@extension("VK_NVX_device_generated_commands") // 87
type VkFlags VkIndirectCommandsLayoutUsageFlagsNVX
@extension("VK_NVX_device_generated_commands") // 87
bitfield VkIndirectCommandsLayoutUsageFlagBitsNVX {
    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX   = 0x00000001,
    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX      = 0x00000002,
    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX      = 0x00000004,
    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX     = 0x00000008,
}

@extension("VK_NVX_device_generated_commands") // 87
type VkFlags VkObjectEntryUsageFlagsNVX
@extension("VK_NVX_device_generated_commands") // 87
bitfield VkObjectEntryUsageFlagBitsNVX {
    VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX                  = 0x00000001,
    VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX                   = 0x00000002,
}

@extension("VK_EXT_display_surface_counter") // 91
type VkFlags VkSurfaceCounterFlagsEXT
@extension("VK_EXT_display_surface_counter") // 91
bitfield VkSurfaceCounterFlagBitsEXT {
    VK_SURFACE_COUNTER_VBLANK_EXT                           = 0x00000001,
}

@extension("VK_NV_viewport_swizzle") // 99
type VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV
//@extension("VK_NV_viewport_swizzle") // 99
//bitfield VkPipelineViewportSwizzleStateCreateFlagBitsNV {
//}

@extension("VK_EXT_discard_rectangles") // 100
type VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT
//@extension("VK_EXT_discard_rectangles") // 100
//bitfield VkPipelineDiscardRectangleStateCreateFlagBitsEXT {
//}

@extension("VK_EXT_conservative_rasterization") // 102
type VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT
//@extension("VK_EXT_conservative_rasterization") // 102
//bitfield VkPipelineRasterizationConservativeStateCreateFlagBitsEXT {
//}

@extension("VK_KHR_external_fence_capabilities") // 113
type VkFlags VkExternalFenceHandleTypeFlagsKHR
@extension("VK_KHR_external_fence_capabilities") // 113
bitfield VkExternalFenceHandleTypeFlagBitsKHR {
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR         = 0x00000001,
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR      = 0x00000002,
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR  = 0x00000004,
    VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR           = 0x00000008,
}

@extension("VK_KHR_external_fence_capabilities") // 113
type VkFlags VkExternalFenceFeatureFlagsKHR
@extension("VK_KHR_external_fence_capabilities") // 113
bitfield VkExternalFenceFeatureFlagBitsKHR {
    VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR            = 0x00000001,
    VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR            = 0x00000002,
}

@extension("VK_KHR_external_fence") // 114
type VkFlags VkFenceImportFlagsKHR
@extension("VK_KHR_external_fence") // 114
bitfield VkFenceImportFlagBitsKHR {
    VK_FENCE_IMPORT_TEMPORARY_BIT_KHR                       = 0x00000001,
}

@extension("VK_MVK_ios_surface") // 123
type VkFlags VkIOSSurfaceCreateFlagsMVK
//@extension("VK_MVK_ios_surface") // 123
//bitfield VkIOSSurfaceCreateFlagBitsMVK {
//}

@extension("VK_MVK_macos_surface") // 124
type VkFlags VkMacOSSurfaceCreateFlagsMVK
//@extension("VK_MVK_macos_surface") // 124
//bitfield VkMacOSSurfaceCreateFlagBitsMVK {
//}

@extension("VK_EXT_debug_utils") // 129
type VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT
//@extension("VK_EXT_debug_utils") // 129
//bitfield VkDebugUtilsMessengerCallbackDataFlagBitsEXT {
//}

@extension("VK_EXT_debug_utils") // 129
type VkFlags VkDebugUtilsMessengerCreateFlagsEXT
//@extension("VK_EXT_debug_utils") // 129
//bitfield VkDebugUtilsMessengerCreateFlagBitsEXT {
//}

@extension("VK_EXT_debug_utils") // 129
type VkFlags VkDebugUtilsMessageSeverityFlagsEXT
@extension("VK_EXT_debug_utils") // 129
bitfield VkDebugUtilsMessageSeverityFlagBitsEXT {
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001,
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT    = 0x00000010,
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100,
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT   = 0x00001000,
}

@extension("VK_EXT_debug_utils") // 129
type VkFlags VkDebugUtilsMessageTypeFlagsEXT
@extension("VK_EXT_debug_utils") // 129
bitfield VkDebugUtilsMessageTypeFlagBitsEXT {
    VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT     = 0x00000001,
    VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT  = 0x00000002,
    VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004,
}

@extension("VK_NV_fragment_coverage_to_color") // 150
type VkFlags VkPipelineCoverageToColorStateCreateFlagsNV
@extension("VK_NV_fragment_coverage_to_color") // 150
//bitfield VkPipelineCoverageToColorStateCreateFlagBitsNV {
//}

@extension("VK_NV_framebuffer_mixed_samples") // 153
type VkFlags VkPipelineCoverageModulationStateCreateFlagsNV
@extension("VK_NV_framebuffer_mixed_samples") // 153
//bitfield VkPipelineCoverageModulationStateCreateFlagBitsNV {
//}

@extension("VK_EXT_validation_cache") // 161
type VkFlags VkValidationCacheCreateFlagsEXT
@extension("VK_EXT_validation_cache") // 161
//bitfield VkValidationCacheCreateFlagBitsEXT {
//}

@extension("VK_EXT_descriptor_indexing") // 162
type VkFlags VkDescriptorBindingFlagsEXT
@extension("VK_EXT_descriptor_indexing") // 162
bitfield VkDescriptorBindingFlagBitsEXT {
    VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT             = 0x00000001,
    VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT   = 0x00000002,
    VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT               = 0x00000004,
    VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT     = 0x00000008,
}

@extension("VK_NVX_raytracing") // 166
type VkFlags VkGeometryFlagsNVX
@extension("VK_NVX_raytracing") // 166
bitfield VkGeometryFlagBitsNVX {
    VK_GEOMETRY_OPAQUE_BIT_NVX                          = 0x00000001,
    VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NVX = 0x00000002,
}

@extension("VK_NVX_raytracing") // 166
type VkFlags VkGeometryInstanceFlagsNVX
@extension("VK_NVX_raytracing") // 166
bitfield VkGeometryInstanceFlagBitsNVX {
    VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NVX      = 0x00000001,
    VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_FLIP_WINDING_BIT_NVX = 0x00000002,
    VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NVX               = 0x00000004,
    VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NVX            = 0x00000008,
}

@extension("VK_NVX_raytracing") // 166
type VkFlags VkBuildAccelerationStructureFlagsNVX
@extension("VK_NVX_raytracing") // 166
bitfield VkBuildAccelerationStructureFlagBitsNVX {
    VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NVX        = 0x00000001,
    VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NVX    = 0x00000002,
    VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NVX   = 0x00000004,
    VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NVX   = 0x00000008,
    VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NVX          = 0x00000010,
}

@extension("VK_FUCHSIA_imagepipe_surface") // 215
type VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA
//@extension("VK_FUCHSIA_imagepipe_surface") // 215
//bitfield VkImagePipeSurfaceCreateFlagBitsFUCHSIA {
//}

//////////////////
//  Structures  //
//////////////////

class VkOffset2D {
    s32                                         x
    s32                                         y
}

class VkOffset3D {
    s32                                         x
    s32                                         y
    s32                                         z
}

class VkExtent2D {
    u32                                         width
    u32                                         height
}

class VkExtent3D {
    u32                                         width
    u32                                         height
    u32                                         depth
}

class VkViewport {
    f32                                         x
    f32                                         y
    f32                                         width
    f32                                         height
    f32                                         minDepth
    f32                                         maxDepth
}

class VkRect2D {
    VkOffset2D                                  offset
    VkExtent2D                                  extent
}

class VkClearRect {
    VkRect2D                                    rect
    u32                                         baseArrayLayer
    u32                                         layerCount
}

class VkComponentMapping {
    VkComponentSwizzle                          r
    VkComponentSwizzle                          g
    VkComponentSwizzle                          b
    VkComponentSwizzle                          a
}

class VkPhysicalDeviceProperties {
    u32                                         apiVersion
    u32                                         driverVersion
    u32                                         vendorID
    u32                                         deviceID
    VkPhysicalDeviceType                        deviceType
    char[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]      deviceName
    u8[VK_UUID_SIZE]                            pipelineCacheUUID
    VkPhysicalDeviceLimits                      limits
    VkPhysicalDeviceSparseProperties            sparseProperties
}

class VkExtensionProperties {
    char[VK_MAX_EXTENSION_NAME_SIZE]            extensionName      /// extension name
    u32                                         specVersion        /// version of the extension specification implemented
}

class VkLayerProperties {
    char[VK_MAX_EXTENSION_NAME_SIZE]            layerName               /// layer name
    u32                                         specVersion             /// version of the layer specification implemented
    u32                                         implementationVersion   /// build or release version of the layer's library
    char[VK_MAX_DESCRIPTION_SIZE]               description             /// Free-form description of the layer
}

class VkSubmitInfo {
    VkStructureType                             sType              /// Type of structure. Should be VK_STRUCTURE_TYPE_SUBMIT_INFO
    const void*                                 pNext              /// Next structure in chain
    u32                                         waitSemaphoreCount
    const VkSemaphore*                          pWaitSemaphores
    const VkPipelineStageFlags*                 pWaitDstStageMask
    u32                                         commandBufferCount
    const VkCommandBuffer*                      pCommandBuffers
    u32                                         signalSemaphoreCount
    const VkSemaphore*                          pSignalSemaphores
}

class VkApplicationInfo {
    VkStructureType                             sType              /// Type of structure. Should be VK_STRUCTURE_TYPE_APPLICATION_INFO
    const void*                                 pNext              /// Next structure in chain
    const char*                                 pApplicationName
    u32                                         applicationVersion
    const char*                                 pEngineName
    u32                                         engineVersion
    u32                                         apiVersion
}

class VkAllocationCallbacks {
    void*                                       pUserData
    PFN_vkAllocationFunction                    pfnAllocation
    PFN_vkReallocationFunction                  pfnReallocation
    PFN_vkFreeFunction                          pfnFree
    PFN_vkInternalAllocationNotification        pfnInternalAllocation
    PFN_vkInternalFreeNotification              pfnInternalFree
}

class VkDeviceQueueCreateInfo {
    VkStructureType                             sStype                    /// Should be VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
    const void*                                 pNext                     /// Pointer to next structure
    VkDeviceQueueCreateFlags                    flags
    u32                                         queueFamilyIndex
    u32                                         queueCount
    const f32*                                  pQueuePriorities
}

class VkDeviceCreateInfo {
    VkStructureType                             sType                      /// Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
    const void*                                 pNext                      /// Pointer to next structure
    VkDeviceCreateFlags                         flags
    u32                                         queueCreateInfoCount
    const VkDeviceQueueCreateInfo*              pQueueCreateInfos
    u32                                         enabledLayerCount
    const char* const*                          ppEnabledLayerNames        /// Ordered list of layer names to be enabled
    u32                                         enabledExtensionCount
    const char* const*                          ppEnabledExtensionNames
    const VkPhysicalDeviceFeatures*             pEnabledFeatures
}

class VkInstanceCreateInfo {
    VkStructureType                             sType                      /// Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
    const void*                                 pNext                      /// Pointer to next structure
    VkInstanceCreateFlags                       flags
    const VkApplicationInfo*                    pApplicationInfo
    u32                                         enabledLayerCount
    const char* const*                          ppEnabledLayerNames        /// Ordered list of layer names to be enabled
    u32                                         enabledExtensionCount
    const char* const*                          ppEnabledExtensionNames    /// Extension names to be enabled
}

class VkQueueFamilyProperties {
    VkQueueFlags                                queueFlags                 /// Queue flags
    u32                                         queueCount
    u32                                         timestampValidBits
    VkExtent3D                                  minImageTransferGranularity
}

class VkPhysicalDeviceMemoryProperties {
    u32                                         memoryTypeCount
    VkMemoryType[VK_MAX_MEMORY_TYPES]           memoryTypes
    u32                                         memoryHeapCount
    VkMemoryHeap[VK_MAX_MEMORY_HEAPS]           memoryHeaps
}

class VkMemoryAllocateInfo {
    VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO
    const void*                                 pNext                      /// Pointer to next structure
    VkDeviceSize                                allocationSize             /// Size of memory allocation
    u32                                         memoryTypeIndex            /// Index of the of the memory type to allocate from
}

class VkMemoryRequirements {
    VkDeviceSize                                size                       /// Specified in bytes
    VkDeviceSize                                alignment                  /// Specified in bytes
    u32                                         memoryTypeBits             /// Bitfield of the allowed memory type indices into memoryTypes[] for this object
}

class VkSparseImageFormatProperties {
    VkImageAspectFlagBits                       aspectMask
    VkExtent3D                                  imageGranularity
    VkSparseImageFormatFlags                    flags
}

class VkSparseImageMemoryRequirements {
    VkSparseImageFormatProperties               formatProperties
    u32                                         imageMipTailFirstLod
    VkDeviceSize                                imageMipTailSize           /// Specified in bytes, must be a multiple of image block size / alignment
    VkDeviceSize                                imageMipTailOffset         /// Specified in bytes, must be a multiple of image block size / alignment
    VkDeviceSize                                imageMipTailStride         /// Specified in bytes, must be a multiple of image block size / alignment
}

class VkMemoryType {
    VkMemoryPropertyFlags                       propertyFlags              /// Memory properties of this memory type
    u32                                         heapIndex                  /// Index of the memory heap allocations of this memory type are taken from
}

class VkMemoryHeap {
    VkDeviceSize                                size                       /// Available memory in the heap
    VkMemoryHeapFlags                           flags                      /// Flags for the heap
}

class VkMappedMemoryRange {
    VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE
    const void*                                 pNext                      /// Pointer to next structure
    VkDeviceMemory                              memory                     /// Mapped memory object
    VkDeviceSize                                offset                     /// Offset within the mapped memory the range starts from
    VkDeviceSize                                size                       /// Size of the range within the mapped memory
}

class VkFormatProperties {
    VkFormatFeatureFlags                        linearTilingFeatures       /// Format features in case of linear tiling
    VkFormatFeatureFlags                        optimalTilingFeatures      /// Format features in case of optimal tiling
    VkFormatFeatureFlags                        bufferFeatures             /// Format features supported by buffers
}

class VkImageFormatProperties {
    VkExtent3D                                  maxExtent                  /// max image dimensions for this resource type
    u32                                         maxMipLevels               /// max number of mipmap levels for this resource type
    u32                                         maxArrayLayers             /// max array layers for this resource type
    VkSampleCountFlags                          sampleCounts               /// supported sample counts for this resource type
    VkDeviceSize                                maxResourceSize            /// max size (in bytes) of this resource type
}

class VkDescriptorImageInfo {
    VkSampler                                   sampler
    VkImageView                                 imageView
    VkImageLayout                               imageLayout
}

class VkDescriptorBufferInfo {
    VkBuffer                                    buffer                     /// Buffer used for this descriptor when the descriptor is UNIFORM_BUFFER[_DYNAMIC]
    VkDeviceSize                                offset                     /// Base offset from buffer start in bytes to update in the descriptor set.
    VkDeviceSize                                range                      /// Size in bytes of the buffer resource for this descriptor update.
}

class VkWriteDescriptorSet {
    VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET
    const void*                                 pNext                      /// Pointer to next structure
    VkDescriptorSet                             dstSet                     /// Destination descriptor set
    u32                                         dstBinding                 /// Binding within the destination descriptor set to write
    u32                                         dstArrayElement            /// Array element within the destination binding to write
    u32                                         descriptorCount            /// Number of descriptors to write (determines the size of the array pointed by <pDescriptors>)
    VkDescriptorType                            descriptorType             /// Descriptor type to write (determines which fields of the array pointed by <pDescriptors> are going to be used)
    const VkDescriptorImageInfo*                pImageInfo
    const VkDescriptorBufferInfo*               pBufferInfo
    const VkBufferView*                         pTexelBufferView
}

class VkCopyDescriptorSet {
    VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET
    const void*                                 pNext                      /// Pointer to next structure
    VkDescriptorSet                             srcSet                     /// Source descriptor set
    u32                                         srcBinding                 /// Binding within the source descriptor set to copy from
    u32                                         srcArrayElement            /// Array element within the source binding to copy from
    VkDescriptorSet                             dstSet                     /// Destination descriptor set
    u32                                         dstBinding                 /// Binding within the destination descriptor set to copy to
    u32                                         dstArrayElement            /// Array element within the destination binding to copy to
    u32                                         descriptorCount            /// Number of descriptors to copy
}

class VkBufferCreateInfo {
    VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
    const void*                                 pNext                      /// Pointer to next structure.
    VkBufferCreateFlags                         flags                      /// Buffer creation flags
    VkDeviceSize                                size                       /// Specified in bytes
    VkBufferUsageFlags                          usage                      /// Buffer usage flags
    VkSharingMode                               sharingMode
    u32                                         queueFamilyIndexCount
    const u32*                                  pQueueFamilyIndices
}

class VkBufferViewCreateInfo {
    VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
    const void*                                 pNext                      /// Pointer to next structure.
    VkBufferViewCreateFlags                     flags
    VkBuffer                                    buffer
    VkFormat                                    format                     /// Optionally specifies format of elements
    VkDeviceSize                                offset                     /// Specified in bytes
    VkDeviceSize                                range                      /// View size specified in bytes
}

class VkImageSubresource {
    VkImageAspectFlagBits                       aspectMask
    u32                                         mipLevel
    u32                                         arrayLayer
}

class VkImageSubresourceRange {
    VkImageAspectFlags                          aspectMask
    u32                                         baseMipLevel
    u32                                         levelCount
    u32                                         baseArrayLayer
    u32                                         layerCount
}

class VkMemoryBarrier {
    VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER
    const void*                                 pNext                      /// Pointer to next structure.
    VkAccessFlags                               srcAccessMask
    VkAccessFlags                               dstAccessMask
}

class VkBufferMemoryBarrier {
    VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
    const void*                                 pNext                      /// Pointer to next structure.
    VkAccessFlags                               srcAccessMask
    VkAccessFlags                               dstAccessMask
    u32                                         srcQueueFamilyIndex        /// Queue family to transition ownership from
    u32                                         dstQueueFamilyIndex        /// Queue family to transition ownership to
    VkBuffer                                    buffer                     /// Buffer to sync
    VkDeviceSize                                offset                     /// Offset within the buffer to sync
    VkDeviceSize                                size                       /// Amount of bytes to sync
}

class VkImageMemoryBarrier {
    VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
    const void*                                 pNext                      /// Pointer to next structure.
    VkAccessFlags                               srcAccessMask
    VkAccessFlags                               dstAccessMask
    VkImageLayout                               oldLayout                  /// Current layout of the image
    VkImageLayout                               newLayout                  /// New layout to transition the image to
    u32                                         srcQueueFamilyIndex        /// Queue family to transition ownership from
    u32                                         dstQueueFamilyIndex        /// Queue family to transition ownership to
    VkImage                                     image                      /// Image to sync
    VkImageSubresourceRange                     subresourceRange           /// Subresource range to sync
}

class VkImageCreateInfo {
    VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
    const void*                                 pNext                      /// Pointer to next structure.
    VkImageCreateFlags                          flags                      /// Image creation flags
    VkImageType                                 imageType
    VkFormat                                    format
    VkExtent3D                                  extent
    u32                                         mipLevels
    u32                                         arrayLayers
    VkSampleCountFlagBits                       samples
    VkImageTiling                               tiling
    VkImageUsageFlags                           usage                      /// Image usage flags
    VkSharingMode                               sharingMode                /// Cross-queue-family sharing mode
    u32                                         queueFamilyIndexCount      /// Number of queue families to share across
    const u32*                                  pQueueFamilyIndices        /// Array of queue family indices to share across
    VkImageLayout                               initialLayout              /// Initial image layout for all subresources
}

class VkSubresourceLayout {
    VkDeviceSize                                offset                 /// Specified in bytes
    VkDeviceSize                                size                   /// Specified in bytes
    VkDeviceSize                                rowPitch               /// Specified in bytes
    VkDeviceSize                                arrayPitch             /// Specified in bytes
    VkDeviceSize                                depthPitch             /// Specified in bytes
}

class VkImageViewCreateInfo {
    VkStructureType                             sType                  /// Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
    const void*                                 pNext                  /// Pointer to next structure
    VkImageViewCreateFlags                      flags
    VkImage                                     image
    VkImageViewType                             viewType
    VkFormat                                    format
    VkComponentMapping                          components
    VkImageSubresourceRange                     subresourceRange
}

class VkBufferCopy {
    VkDeviceSize                                srcOffset              /// Specified in bytes
    VkDeviceSize                                dstOffset              /// Specified in bytes
    VkDeviceSize                                size                   /// Specified in bytes
}

class VkSparseMemoryBind {
    VkDeviceSize                                resourceOffset        /// Specified in bytes
    VkDeviceSize                                size                  /// Specified in bytes
    VkDeviceMemory                              memory
    VkDeviceSize                                memoryOffset          /// Specified in bytes
    VkSparseMemoryBindFlags                     flags
}

class VkSparseImageMemoryBind {
    VkImageSubresource                          subresource
    VkOffset3D                                  offset
    VkExtent3D                                  extent
    VkDeviceMemory                              memory
    VkDeviceSize                                memoryOffset          /// Specified in bytes
    VkSparseMemoryBindFlags                     flags
}

class VkSparseBufferMemoryBindInfo {
    VkBuffer                                    buffer
    u32                                         bindCount
    const VkSparseMemoryBind*                   pBinds
}

class VkSparseImageOpaqueMemoryBindInfo {
    VkImage                                     image
    u32                                         bindCount
    const VkSparseMemoryBind*                   pBinds
}

class VkSparseImageMemoryBindInfo {
    VkImage                                     image
    u32                                         bindCount
    const VkSparseMemoryBind*                   pBinds
}

class VkBindSparseInfo {
    VkStructureType                             sType                 /// Must be VK_STRUCTURE_TYPE_BIND_SPARSE_INFO
    const void*                                 pNext
    u32                                         waitSemaphoreCount
    const VkSemaphore*                          pWaitSemaphores
    u32                                         numBufferBinds
    const VkSparseBufferMemoryBindInfo*         pBufferBinds
    u32                                         numImageOpaqueBinds
    const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds
    u32                                         numImageBinds
    const VkSparseImageMemoryBindInfo*          pImageBinds
    u32                                         signalSemaphoreCount
    const VkSemaphore*                          pSignalSemaphores
}

class VkImageSubresourceLayers {
    VkImageAspectFlags                          aspectMask
    u32                                         mipLevel
    u32                                         baseArrayLayer
    u32                                         layerCount
}

class VkImageCopy {
    VkImageSubresourceLayers                    srcSubresource
    VkOffset3D                                  srcOffset             /// Specified in pixels for both compressed and uncompressed images
    VkImageSubresourceLayers                    dstSubresource
    VkOffset3D                                  dstOffset             /// Specified in pixels for both compressed and uncompressed images
    VkExtent3D                                  extent                /// Specified in pixels for both compressed and uncompressed images
}

class VkImageBlit {
    VkImageSubresourceLayers                    srcSubresource
    VkOffset3D[2]                               srcOffsets
    VkImageSubresourceLayers                    dstSubresource
    VkOffset3D[2]                               dstOffsets
}

class VkBufferImageCopy {
    VkDeviceSize                                bufferOffset           /// Specified in bytes
    u32                                         bufferRowLength        /// Specified in texels
    u32                                         bufferImageHeight
    VkImageSubresourceLayers                    imageSubresource
    VkOffset3D                                  imageOffset            /// Specified in pixels for both compressed and uncompressed images
    VkExtent3D                                  imageExtent            /// Specified in pixels for both compressed and uncompressed images
}

class VkImageResolve {
    VkImageSubresourceLayers                    srcSubresource
    VkOffset3D                                  srcOffset
    VkImageSubresourceLayers                    dstSubresource
    VkOffset3D                                  dstOffset
    VkExtent3D                                  extent
}

class VkShaderModuleCreateInfo {
    VkStructureType                             sType                  /// Must be VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO
    const void*                                 pNext                  /// Pointer to next structure
    VkShaderModuleCreateFlags                   flags                  /// Reserved
    platform.size_t                             codeSize               /// Specified in bytes
    const u32*                                  pCode                  /// Binary code of size codeSize
}

class VkDescriptorSetLayoutBinding {
    u32                                         binding
    VkDescriptorType                            descriptorType     /// Type of the descriptors in this binding
    u32                                         descriptorCount    /// Number of descriptors in this binding
    VkShaderStageFlags                          stageFlags         /// Shader stages this binding is visible to
    const VkSampler*                            pImmutableSamplers /// Immutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains <count> number of elements)
}

class VkDescriptorSetLayoutCreateInfo {
    VkStructureType                             sType              /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
    const void*                                 pNext              /// Pointer to next structure
    VkDescriptorSetLayoutCreateFlags            flags
    u32                                         bindingCount       /// Number of bindings in the descriptor set layout
    const VkDescriptorSetLayoutBinding*         pBindings          /// Array of descriptor set layout bindings
}

class VkDescriptorPoolSize {
    VkDescriptorType                            type
    u32                                         descriptorCount
}

class VkDescriptorPoolCreateInfo {
    VkStructureType                             sType              /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
    const void*                                 pNext              /// Pointer to next structure
    VkDescriptorPoolCreateFlags                 flags
    u32                                         maxSets
    u32                                         poolSizeCount
    const VkDescriptorPoolSize*                 pPoolSizes
}

class VkDescriptorSetAllocateInfo {
    VkStructureType                             sType              /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO
    const void*                                 pNext              /// Pointer to next structure
    VkDescriptorPool                            descriptorPool
    u32                                         setCount
    const VkDescriptorSetLayout*                pSetLayouts
}

class VkSpecializationMapEntry {
    u32                                         constantID         /// The SpecConstant ID specified in the BIL
    u32                                         offset             /// Offset of the value in the data block
    platform.size_t                             size               /// Size in bytes of the SpecConstant
}

class VkSpecializationInfo {
    u32                                         mapEntryCount      /// Number of entries in the map
    const VkSpecializationMapEntry*             pMapEntries        /// Array of map entries
    platform.size_t                             dataSize           /// Size in bytes of pData
    const void*                                 pData              /// Pointer to SpecConstant data
}

class VkPipelineShaderStageCreateInfo {
    VkStructureType                             sType              /// Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
    const void*                                 pNext              /// Pointer to next structure
    VkPipelineShaderStageCreateFlags            flags
    VkShaderStageFlagBits                       stage
    VkShaderModule                              module
    const char*                                 pName
    const VkSpecializationInfo*                 pSpecializationInfo
}

class VkComputePipelineCreateInfo {
    VkStructureType                             sType              /// Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
    const void*                                 pNext              /// Pointer to next structure
    VkPipelineCreateFlags                       flags              /// Pipeline creation flags
    VkPipelineShaderStageCreateInfo             stage
    VkPipelineLayout                            layout             /// Interface layout of the pipeline
    VkPipeline                                  basePipelineHandle /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of
    s32                                         basePipelineIndex  /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of
}

class VkVertexInputBindingDescription {
    u32                                         binding               /// Vertex buffer binding id
    u32                                         stride                /// Distance between vertices in bytes (0 = no advancement)
    VkVertexInputRate                           inputRate             /// Rate at which binding is incremented
}

class VkVertexInputAttributeDescription {
    u32                                         location              /// location of the shader vertex attrib
    u32                                         binding               /// Vertex buffer binding id
    VkFormat                                    format                /// format of source data
    u32                                         offset                /// Offset of first element in bytes from base of vertex
}

class VkPipelineVertexInputStateCreateInfo {
    VkStructureType                             sType                           /// Should be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
    const void*                                 pNext                           /// Pointer to next structure
    VkPipelineVertexInputStateCreateFlags       flags
    u32                                         vertexBindingDescriptionCount   /// number of bindings
    const VkVertexInputBindingDescription*      pVertexBindingDescriptions
    u32                                         vertexAttributeDescriptionCount /// number of attributes
    const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions
}

class VkPipelineInputAssemblyStateCreateInfo {
    VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO
    const void*                                 pNext      /// Pointer to next structure
    VkPipelineInputAssemblyStateCreateFlags     flags
    VkPrimitiveTopology                         topology
    VkBool32                                    primitiveRestartEnable
}

class VkPipelineTessellationStateCreateInfo {
    VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO
    const void*                                 pNext      /// Pointer to next structure
    VkPipelineTessellationStateCreateFlags      flags
    u32                                         patchControlPoints
}

class VkPipelineViewportStateCreateInfo {
    VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO
    const void*                                 pNext      /// Pointer to next structure
    VkPipelineViewportStateCreateFlags          flags
    u32                                         viewportCount
    const VkViewport*                           pViewports
    u32                                         scissorCount
    const VkRect2D*                             pScissors
}

class VkPipelineRasterizationStateCreateInfo {
    VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO
    const void*                                 pNext      /// Pointer to next structure
    VkPipelineRasterizationStateCreateFlags     flags
    VkBool32                                    depthClampEnable
    VkBool32                                    rasterizerDiscardEnable
    VkPolygonMode                               polygonMode                   /// optional (GL45)
    VkCullModeFlags                             cullMode
    VkFrontFace                                 frontFace
    VkBool32                                    depthBiasEnable
    f32                                         depthBiasConstantFactor
    f32                                         depthBiasClamp
    f32                                         depthBiasSlopeFactor
    f32                                         lineWidth
}

class VkPipelineMultisampleStateCreateInfo {
    VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO
    const void*                                 pNext      /// Pointer to next structure
    VkPipelineMultisampleStateCreateFlags       flags
    VkSampleCountFlagBits                       rasterizationSamples       /// Number of samples used for rasterization
    VkBool32                                    sampleShadingEnable        /// optional (GL45)
    f32                                         minSampleShading           /// optional (GL45)
    const VkSampleMask*                         pSampleMask
    VkBool32                                    alphaToCoverageEnable
    VkBool32                                    alphaToOneEnable
}

class VkPipelineColorBlendAttachmentState {
    VkBool32                                    blendEnable
    VkBlendFactor                               srcColorBlendFactor
    VkBlendFactor                               dstColorBlendFactor
    VkBlendOp                                   colorBlendOp
    VkBlendFactor                               srcAlphaBlendFactor
    VkBlendFactor                               dstAlphaBlendFactor
    VkBlendOp                                   alphaBlendOp
    VkColorComponentFlags                       colorWriteMask
}

class VkPipelineColorBlendStateCreateInfo {
    VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO
    const void*                                 pNext      /// Pointer to next structure
    VkPipelineColorBlendStateCreateFlags        flags
    VkBool32                                    logicOpEnable
    VkLogicOp                                   logicOp
    u32                                         attachmentCount    /// # of pAttachments
    const VkPipelineColorBlendAttachmentState*  pAttachments
    f32[4]                                      blendConstants
}

class VkStencilOpState {
    VkStencilOp                                 failOp
    VkStencilOp                                 passOp
    VkStencilOp                                 depthFailOp
    VkCompareOp                                 compareOp
    u32                                         compareMask
    u32                                         writeMask
    u32                                         reference
}

class VkPipelineDepthStencilStateCreateInfo {
    VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
    const void*                                 pNext      /// Pointer to next structure
    VkPipelineDepthStencilStateCreateFlags      flags
    VkBool32                                    depthTestEnable
    VkBool32                                    depthWriteEnable
    VkCompareOp                                 depthCompareOp
    VkBool32                                    depthBoundsTestEnable  /// optional (depth_bounds_test)
    VkBool32                                    stencilTestEnable
    VkStencilOpState                            front
    VkStencilOpState                            back
    f32                                         minDepthBounds
    f32                                         maxDepthBounds
}

class VkPipelineDynamicStateCreateInfo {
    VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO
    const void*                                 pNext      /// Pointer to next structure
    VkPipelineDynamicStateCreateFlags           flags
    u32                                         dynamicStateCount
    const VkDynamicState*                       pDynamicStates
}

class VkGraphicsPipelineCreateInfo {
    VkStructureType                                 sType               /// Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
    const void*                                     pNext               /// Pointer to next structure
    VkPipelineCreateFlags                           flags               /// Pipeline creation flags
    u32                                             stageCount
    const VkPipelineShaderStageCreateInfo*          pStages             /// One entry for each active shader stage
    const VkPipelineVertexInputStateCreateInfo*     pVertexInputState
    const VkPipelineInputAssemblyStateCreateInfo*   pInputAssemblyState
    const VkPipelineTessellationStateCreateInfo*    pTessellationState
    const VkPipelineViewportStateCreateInfo*        pViewportState
    const VkPipelineRasterizationStateCreateInfo*   pRasterizationState
    const VkPipelineMultisampleStateCreateInfo*     pMultisampleState
    const VkPipelineDepthStencilStateCreateInfo*    pDepthStencilState
    const VkPipelineColorBlendStateCreateInfo*      pColorBlendState
    const VkPipelineDynamicStateCreateInfo*         pDynamicState
    VkPipelineLayout                                layout              /// Interface layout of the pipeline
    VkRenderPass                                    renderPass
    u32                                             subpass
    VkPipeline                                      basePipelineHandle  /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of
    s32                                             basePipelineIndex   /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of
}

class VkPipelineCacheCreateInfo {
    VkStructureType                             sType                 /// Must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
    const void*                                 pNext                 /// Pointer to next structure
    VkPipelineCacheCreateFlags                  flags
    platform.size_t                             initialDataSize       /// Size of initial data to populate cache, in bytes
    const void*                                 pInitialData          /// Initial data to populate cache
}

class VkPushConstantRange {
    VkShaderStageFlags                          stageFlags   /// Which stages use the range
    u32                                         offset       /// Start of the range, in bytes
    u32                                         size        /// Length of the range, in bytes
}

class VkPipelineLayoutCreateInfo {
    VkStructureType                             sType                   /// Must be VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
    const void*                                 pNext                   /// Pointer to next structure
    VkPipelineLayoutCreateFlags                 flags
    u32                                         descriptorSetCount      /// Number of descriptor sets interfaced by the pipeline
    const VkDescriptorSetLayout*                pSetLayouts             /// Array of <setCount> number of descriptor set layout objects defining the layout of the
    u32                                         pushConstantRangeCount  /// Number of push-constant ranges used by the pipeline
    const VkPushConstantRange*                  pPushConstantRanges     /// Array of pushConstantRangeCount number of ranges used by various shader stages
}

class VkSamplerCreateInfo {
    VkStructureType                             sType          /// Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
    const void*                                 pNext          /// Pointer to next structure
    VkSamplerCreateFlags                        flags
    VkFilter                                    magFilter      /// Filter mode for magnification
    VkFilter                                    minFilter      /// Filter mode for minifiation
    VkSamplerMipmapMode                         mipmapMode     /// Mipmap selection mode
    VkSamplerAddressMode                        addressModeU
    VkSamplerAddressMode                        addressModeV
    VkSamplerAddressMode                        addressModeW
    f32                                         mipLodBias
    VkBool32                                    anisotropyEnable
    f32                                         maxAnisotropy
    VkBool32                                    compareEnable
    VkCompareOp                                 compareOp
    f32                                         minLod
    f32                                         maxLod
    VkBorderColor                               borderColor
    VkBool32                                    unnormalizedCoordinates
}

class VkCommandPoolCreateInfo {
    VkStructureType                             sType            /// Must be VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
    const void*                                 pNext            /// Pointer to next structure
    VkCommandPoolCreateFlags                    flags            /// Command pool creation flags
    u32                                         queueFamilyIndex
}

class VkCommandBufferAllocateInfo {
    VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
    const void*                                 pNext      /// Pointer to next structure
    VkCommandPool                               commandPool
    VkCommandBufferLevel                        level
    u32                                         commandBufferCount
}

class VkCommandBufferInheritanceInfo {
    VkStructureType                             sType       /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO
    const void*                                 pNext       /// Pointer to next structure
    VkRenderPass                                renderPass  /// Render pass for secondary command buffers
    u32                                         subpass
    VkFramebuffer                               framebuffer /// Framebuffer for secondary command buffers
    VkBool32                                    occlusionQueryEnable
    VkQueryControlFlags                         queryFlags
    VkQueryPipelineStatisticFlags               pipelineStatistics
}

class VkCommandBufferBeginInfo {
    VkStructureType                             sType       /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
    const void*                                 pNext       /// Pointer to next structure
    VkCommandBufferUsageFlags                   flags       /// Command buffer usage flags
    const VkCommandBufferInheritanceInfo*       pInheritanceInfo
}

class VkRenderPassBeginInfo {
    VkStructureType                             sType       /// Must be VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO
    const void*                                 pNext       /// Pointer to next structure
    VkRenderPass                                renderPass
    VkFramebuffer                               framebuffer
    VkRect2D                                    renderArea
    u32                                         clearValueCount
    const VkClearValue*                         pClearValues
}

@union
/// Union allowing specification of floating point, integer, or unsigned integer color data. Actual value selected is based on image/attachment being cleared.
class VkClearColorValue {
    f32[4]                                      float32
    s32[4]                                      int32
    u32[4]                                      uint32
}

class VkClearDepthStencilValue {
    f32                                         depth
    u32                                         stencil
}

@union
/// Union allowing specification of color, depth, and stencil color values. Actual value selected is based on attachment being cleared.
class VkClearValue {
    VkClearColorValue                           color
    VkClearDepthStencilValue                    depthStencil
}

class VkClearAttachment {
    VkImageAspectFlags                          aspectMask
    u32                                         colorAttachment
    VkClearValue                                clearValue
}

class VkAttachmentDescription {
    VkAttachmentDescriptionFlags                flags
    VkFormat                                    format
    VkSampleCountFlagBits                       samples
    VkAttachmentLoadOp                          loadOp          /// Load op for color or depth data
    VkAttachmentStoreOp                         storeOp         /// Store op for color or depth data
    VkAttachmentLoadOp                          stencilLoadOp   /// Load op for stencil data
    VkAttachmentStoreOp                         stencilStoreOp  /// Store op for stencil data
    VkImageLayout                               initialLayout
    VkImageLayout                               finalLayout
}

class VkAttachmentReference {
    u32                                         attachment
    VkImageLayout                               layout
}

class VkSubpassDescription {
    VkSubpassDescriptionFlags                   flags
    VkPipelineBindPoint                         pipelineBindPoint  /// Must be VK_PIPELINE_BIND_POINT_GRAPHICS for now
    u32                                         inputAttachmentCount
    const VkAttachmentReference*                pInputAttachments
    u32                                         colorAttachmentCount
    const VkAttachmentReference*                pColorAttachments
    const VkAttachmentReference*                pResolveAttachments
    const VkAttachmentReference*                pDepthStencilAttachment
    u32                                         preserveAttachmentCount
    const u32*                                  pPreserveAttachments
}

class VkSubpassDependency {
    u32                                         srcSubpass
    u32                                         dstSubpass
    VkPipelineStageFlags                        srcStageMask
    VkPipelineStageFlags                        dstStageMask
    VkAccessFlags                               srcAccessMask
    VkAccessFlags                               dstAccessMask
    VkDependencyFlags                           dependencyFlags
}

class VkRenderPassCreateInfo {
    VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
    const void*                                 pNext      /// Pointer to next structure
    VkRenderPassCreateFlags                     flags
    u32                                         attachmentCount
    const VkAttachmentDescription*              pAttachments
    u32                                         subpassCount
    const VkSubpassDescription*                 pSubpasses
    u32                                         dependencyCount
    const VkSubpassDependency*                  pDependencies
}

class VkEventCreateInfo {
    VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO
    const void*                                 pNext      /// Pointer to next structure
    VkEventCreateFlags                          flags      /// Event creation flags
}

class VkFenceCreateInfo {
    VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
    const void*                                 pNext      /// Pointer to next structure
    VkFenceCreateFlags                          flags      /// Fence creation flags
}

class VkPhysicalDeviceFeatures {
    VkBool32                                    robustBufferAccess                        /// out of bounds buffer accesses are well defined
    VkBool32                                    fullDrawIndexUint32                       /// full 32-bit range of indices for indexed draw calls
    VkBool32                                    imageCubeArray                            /// image views which are arrays of cube maps
    VkBool32                                    independentBlend                          /// blending operations are controlled per-attachment
    VkBool32                                    geometryShader                            /// geometry stage
    VkBool32                                    tessellationShader                        /// tessellation control and evaluation stage
    VkBool32                                    sampleRateShading                         /// per-sample shading and interpolation
    VkBool32                                    dualSrcBlend                              /// blend operations which take two sources
    VkBool32                                    logicOp                                   /// logic operations
    VkBool32                                    multiDrawIndirect                         /// multi draw indirect
    VkBool32                                    drawIndirectFirstInstance
    VkBool32                                    depthClamp                                /// depth clamping
    VkBool32                                    depthBiasClamp                            /// depth bias clamping
    VkBool32                                    fillModeNonSolid                          /// point and wireframe fill modes
    VkBool32                                    depthBounds                               /// depth bounds test
    VkBool32                                    wideLines                                 /// lines with width greater than 1
    VkBool32                                    largePoints                               /// points with size greater than 1
    VkBool32                                    alphaToOne                                /// The fragment alpha channel can be forced to maximum representable alpha value
    VkBool32                                    multiViewport
    VkBool32                                    samplerAnisotropy
    VkBool32                                    textureCompressionETC2                    /// ETC texture compression formats
    VkBool32                                    textureCompressionASTC_LDR                /// ASTC LDR texture compression formats
    VkBool32                                    textureCompressionBC                      /// BC1-7 texture compressed formats
    VkBool32                                    occlusionQueryPrecise
    VkBool32                                    pipelineStatisticsQuery                   /// pipeline statistics query
    VkBool32                                    vertexPipelineStoresAndAtomics
    VkBool32                                    fragmentStoresAndAtomics
    VkBool32                                    shaderTessellationAndGeometryPointSize
    VkBool32                                    shaderImageGatherExtended                 /// texture gather with run-time values and independent offsets
    VkBool32                                    shaderStorageImageExtendedFormats         /// the extended set of formats can be used for storage images
    VkBool32                                    shaderStorageImageMultisample             /// multisample images can be used for storage images
    VkBool32                                    shaderStorageImageReadWithoutFormat
    VkBool32                                    shaderStorageImageWriteWithoutFormat
    VkBool32                                    shaderUniformBufferArrayDynamicIndexing   /// arrays of uniform buffers can be accessed with dynamically uniform indices
    VkBool32                                    shaderSampledImageArrayDynamicIndexing    /// arrays of sampled images can be accessed with dynamically uniform indices
    VkBool32                                    shaderStorageBufferArrayDynamicIndexing   /// arrays of storage buffers can be accessed with dynamically uniform indices
    VkBool32                                    shaderStorageImageArrayDynamicIndexing    /// arrays of storage images can be accessed with dynamically uniform indices
    VkBool32                                    shaderClipDistance                        /// clip distance in shaders
    VkBool32                                    shaderCullDistance                        /// cull distance in shaders
    VkBool32                                    shaderFloat64                             /// 64-bit floats (doubles) in shaders
    VkBool32                                    shaderInt64                               /// 64-bit integers in shaders
    VkBool32                                    shaderInt16                               /// 16-bit integers in shaders
    VkBool32                                    shaderResourceResidency                   /// shader can use texture operations that return resource residency information (requires sparseNonResident support)
    VkBool32                                    shaderResourceMinLod                      /// shader can use texture operations that specify minimum resource LOD
    VkBool32                                    sparseBinding                             /// Sparse resources support: Resource memory can be managed at opaque page level rather than object level
    VkBool32                                    sparseResidencyBuffer                     /// Sparse resources support: GPU can access partially resident buffers
    VkBool32                                    sparseResidencyImage2D                    /// Sparse resources support: GPU can access partially resident 2D (non-MSAA non-DepthStencil) images
    VkBool32                                    sparseResidencyImage3D                    /// Sparse resources support: GPU can access partially resident 3D images
    VkBool32                                    sparseResidency2Samples                   /// Sparse resources support: GPU can access partially resident MSAA 2D images with 2 samples
    VkBool32                                    sparseResidency4Samples                   /// Sparse resources support: GPU can access partially resident MSAA 2D images with 4 samples
    VkBool32                                    sparseResidency8Samples                   /// Sparse resources support: GPU can access partially resident MSAA 2D images with 8 samples
    VkBool32                                    sparseResidency16Samples                  /// Sparse resources support: GPU can access partially resident MSAA 2D images with 16 samples
    VkBool32                                    sparseResidencyAliased                    /// Sparse resources support: GPU can correctly access data aliased into multiple locations (opt-in)
    VkBool32                                    variableMultisampleRate
    VkBool32                                    inheritedQueries
}

class VkPhysicalDeviceLimits {
    /// resource maximum sizes
    u32                                         maxImageDimension1D                       /// max 1D image dimension
    u32                                         maxImageDimension2D                       /// max 2D image dimension
    u32                                         maxImageDimension3D                       /// max 3D image dimension
    u32                                         maxImageDimensionCube                     /// max cubemap image dimension
    u32                                         maxImageArrayLayers                       /// max layers for image arrays
    u32                                         maxTexelBufferElements
    u32                                         maxUniformBufferRange                     /// max uniform buffer size (bytes)
    u32                                         maxStorageBufferRange                     /// max storage buffer size (bytes)
    u32                                         maxPushConstantsSize                      /// max size of the push constants pool (bytes)
    /// memory limits
    u32                                         maxMemoryAllocationCount                  /// max number of device memory allocations supported
    u32                                         maxSamplerAllocationCount
    VkDeviceSize                                bufferImageGranularity                    /// Granularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage
    VkDeviceSize                                sparseAddressSpaceSize                    /// Total address space available for sparse allocations (bytes)
    /// descriptor set limits
    u32                                         maxBoundDescriptorSets                    /// max number of descriptors sets that can be bound to a pipeline
    u32                                         maxPerStageDescriptorSamplers             /// max num of samplers allowed per-stage in a descriptor set
    u32                                         maxPerStageDescriptorUniformBuffers       /// max num of uniform buffers allowed per-stage in a descriptor set
    u32                                         maxPerStageDescriptorStorageBuffers       /// max num of storage buffers allowed per-stage in a descriptor set
    u32                                         maxPerStageDescriptorSampledImages        /// max num of sampled images allowed per-stage in a descriptor set
    u32                                         maxPerStageDescriptorStorageImages        /// max num of storage images allowed per-stage in a descriptor set
    u32                                         maxPerStageDescriptorInputAttachments
    u32                                         maxPerStageResources
    u32                                         maxDescriptorSetSamplers                  /// max num of samplers allowed in all stages in a descriptor set
    u32                                         maxDescriptorSetUniformBuffers            /// max num of uniform buffers allowed in all stages in a descriptor set
    u32                                         maxDescriptorSetUniformBuffersDynamic     /// max num of dynamic uniform buffers allowed in all stages in a descriptor set
    u32                                         maxDescriptorSetStorageBuffers            /// max num of storage buffers allowed in all stages in a descriptor set
    u32                                         maxDescriptorSetStorageBuffersDynamic     /// max num of dynamic storage buffers allowed in all stages in a descriptor set
    u32                                         maxDescriptorSetSampledImages             /// max num of sampled images allowed in all stages in a descriptor set
    u32                                         maxDescriptorSetStorageImages             /// max num of storage images allowed in all stages in a descriptor set
    u32                                         maxDescriptorSetInputAttachments
    /// vertex stage limits
    u32                                         maxVertexInputAttributes                  /// max num of vertex input attribute slots
    u32                                         maxVertexInputBindings                    /// max num of vertex input binding slots
    u32                                         maxVertexInputAttributeOffset             /// max vertex input attribute offset added to vertex buffer offset
    u32                                         maxVertexInputBindingStride               /// max vertex input binding stride
    u32                                         maxVertexOutputComponents                 /// max num of output components written by vertex shader
    /// tessellation control stage limits
    u32                                         maxTessellationGenerationLevel                  /// max level supported by tess primitive generator
    u32                                         maxTessellationPatchSize                        /// max patch size (vertices)
    u32                                         maxTessellationControlPerVertexInputComponents  /// max num of input components per-vertex in TCS
    u32                                         maxTessellationControlPerVertexOutputComponents /// max num of output components per-vertex in TCS
    u32                                         maxTessellationControlPerPatchOutputComponents  /// max num of output components per-patch in TCS
    u32                                         maxTessellationControlTotalOutputComponents     /// max total num of per-vertex and per-patch output components in TCS
    u32                                         maxTessellationEvaluationInputComponents        /// max num of input components per vertex in TES
    u32                                         maxTessellationEvaluationOutputComponents       /// max num of output components per vertex in TES
    /// geometry stage limits
    u32                                         maxGeometryShaderInvocations              /// max invocation count supported in geometry shader
    u32                                         maxGeometryInputComponents                /// max num of input components read in geometry stage
    u32                                         maxGeometryOutputComponents               /// max num of output components written in geometry stage
    u32                                         maxGeometryOutputVertices                 /// max num of vertices that can be emitted in geometry stage
    u32                                         maxGeometryTotalOutputComponents          /// max total num of components (all vertices) written in geometry stage
    /// fragment stage limits
    u32                                         maxFragmentInputComponents                /// max num of input compontents read in fragment stage
    u32                                         maxFragmentOutputAttachments              /// max num of output attachments written in fragment stage
    u32                                         maxFragmentDualSrcAttachments             /// max num of output attachments written when using dual source blending
    u32                                         maxFragmentCombinedOutputResources        /// max total num of storage buffers, storage images and output buffers
    /// compute stage limits
    u32                                         maxComputeSharedMemorySize                /// max total storage size of work group local storage (bytes)
    u32[3]                                      maxComputeWorkGroupCount                  /// max num of compute work groups that may be dispatched by a single command (x,y,z)
    u32                                         maxComputeWorkGroupInvocations            /// max total compute invocations in a single local work group
    u32[3]                                      maxComputeWorkGroupSize                   /// max local size of a compute work group (x,y,z)

    u32                                         subPixelPrecisionBits                     /// num bits of subpixel precision in screen x and y
    u32                                         subTexelPrecisionBits                     /// num bits of subtexel precision
    u32                                         mipmapPrecisionBits                       /// num bits of mipmap precision

    u32                                         maxDrawIndexedIndexValue                  /// max index value for indexed draw calls (for 32-bit indices)
    u32                                         maxDrawIndirectCount

    f32                                         maxSamplerLodBias                         /// max absolute sampler level of detail bias
    f32                                         maxSamplerAnisotropy                      /// max degree of sampler anisotropy

    u32                                         maxViewports                              /// max number of active viewports
    u32[2]                                      maxViewportDimensions                     /// max viewport dimensions (x,y)
    f32[2]                                      viewportBoundsRange                       /// viewport bounds range (min,max)
    u32                                         viewportSubPixelBits                      /// num bits of subpixel precision for viewport

    platform.size_t                             minMemoryMapAlignment                     /// min required alignment of pointers returned by MapMemory (bytes)
    VkDeviceSize                                minTexelBufferOffsetAlignment             /// min required alignment for texel buffer offsets (bytes)
    VkDeviceSize                                minUniformBufferOffsetAlignment           /// min required alignment for uniform buffer sizes and offsets (bytes)
    VkDeviceSize                                minStorageBufferOffsetAlignment           /// min required alignment for storage buffer offsets (bytes)

    s32                                         minTexelOffset                            /// min texel offset for OpTextureSampleOffset
    u32                                         maxTexelOffset                            /// max texel offset for OpTextureSampleOffset
    s32                                         minTexelGatherOffset                      /// min texel offset for OpTextureGatherOffset
    u32                                         maxTexelGatherOffset                      /// max texel offset for OpTextureGatherOffset
    f32                                         minInterpolationOffset                    /// furthest negative offset for interpolateAtOffset
    f32                                         maxInterpolationOffset                    /// furthest positive offset for interpolateAtOffset
    u32                                         subPixelInterpolationOffsetBits           /// num of subpixel bits for interpolateAtOffset

    u32                                         maxFramebufferWidth                       /// max width for a framebuffer
    u32                                         maxFramebufferHeight                      /// max height for a framebuffer
    u32                                         maxFramebufferLayers                      /// max layer count for a layered framebuffer
    VkSampleCountFlags                          framebufferColorSampleCounts
    VkSampleCountFlags                          framebufferDepthSampleCounts
    VkSampleCountFlags                          framebufferStencilSampleCounts
    VkSampleCountFlags                          framebufferNoAttachmentSampleCounts
    u32                                         maxColorAttachments                       /// max num of framebuffer color attachments

    VkSampleCountFlags                          sampledImageColorSampleCounts
    VkSampleCountFlags                          sampledImageIntegerSampleCounts
    VkSampleCountFlags                          sampledImageDepthSampleCounts
    VkSampleCountFlags                          sampledImageStencilSampleCounts
    VkSampleCountFlags                          storageImageSampleCounts
    u32                                         maxSampleMaskWords                        /// max num of sample mask words
    VkBool32                                    timestampComputeAndGraphics

    f32                                         timestampPeriod

    u32                                         maxClipDistances                          /// max number of clip distances
    u32                                         maxCullDistances                          /// max number of cull distances
    u32                                         maxCombinedClipAndCullDistances           /// max combined number of user clipping

    u32                                         discreteQueuePriorities

    f32[2]                                      pointSizeRange                            /// range (min,max) of supported point sizes
    f32[2]                                      lineWidthRange                            /// range (min,max) of supported line widths
    f32                                         pointSizeGranularity                      /// granularity of supported point sizes
    f32                                         lineWidthGranularity                      /// granularity of supported line widths
    VkBool32                                    strictLines
    VkBool32                                    standardSampleLocations

    VkDeviceSize                                optimalBufferCopyOffsetAlignment
    VkDeviceSize                                optimalBufferCopyRowPitchAlignment
    VkDeviceSize                                nonCoherentAtomSize
}

class VkPhysicalDeviceSparseProperties {
    VkBool32                                    residencyStandard2DBlockShape             /// Sparse resources support: GPU will access all 2D (single sample) sparse resources using the standard block shapes (based on pixel format)
    VkBool32                                    residencyStandard2DMultisampleBlockShape  /// Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard block shapes (based on pixel format)
    VkBool32                                    residencyStandard3DBlockShape             /// Sparse resources support: GPU will access all 3D sparse resources using the standard block shapes (based on pixel format)
    VkBool32                                    residencyAlignedMipSize                   /// Sparse resources support: Images with mip-level dimensions that are NOT a multiple of the block size will be placed in the mip tail
    VkBool32                                    residencyNonResidentStrict                /// Sparse resources support: GPU can safely access non-resident regions of a resource, all reads return as if data is 0, writes are discarded
}

class VkSemaphoreCreateInfo {
    VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
    const void*                                 pNext      /// Pointer to next structure
    VkSemaphoreCreateFlags                      flags      /// Semaphore creation flags
}

class VkQueryPoolCreateInfo {
    VkStructureType                             sType              /// Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
    const void*                                 pNext              /// Pointer to next structure
    VkQueryPoolCreateFlags                      flags
    VkQueryType                                 queryType
    u32                                         queryCount
    VkQueryPipelineStatisticFlags               pipelineStatistics /// Optional
}

class VkFramebufferCreateInfo {
    VkStructureType                             sType  /// Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
    const void*                                 pNext  /// Pointer to next structure
    VkFramebufferCreateFlags                    flags
    VkRenderPass                                renderPass
    u32                                         attachmentCount
    const VkImageView*                          pAttachments
    u32                                         width
    u32                                         height
    u32                                         layers
}

class VkDrawIndirectCommand {
    u32                                         vertexCount
    u32                                         instanceCount
    u32                                         firstVertex
    u32                                         firstInstance
}

class VkDrawIndexedIndirectCommand {
    u32                                         indexCount
    u32                                         instanceCount
    u32                                         firstIndex
    s32                                         vertexOffset
    u32                                         firstInstance
}

class VkDispatchIndirectCommand {
    u32                                         x
    u32                                         y
    u32                                         z
}

class VkBaseOutStructure {
    VkStructureType                             sType
    void*                                       pNext
}

class VkBaseInStructure {
    VkStructureType                             sType
    const void*                                 pNext
}

//@vulkan1_1 structures

class VkPhysicalDeviceSubgroupProperties {
    VkStructureType                             sType
    void*                                       pNext
    u32                                         subgroupSize
    VkShaderStageFlags                          supportedStages
    VkSubgroupFeatureFlags                      supportedOperations
    VkBool32                                    quadOperationsInAllStages
}

class VkBindBufferMemoryInfo {
    VkStructureType    sType
    const void*        pNext
    VkBuffer           buffer
    VkDeviceMemory     memory
    VkDeviceSize       memoryOffset
}

class VkBindImageMemoryInfo {
    VkStructureType    sType
    const void*        pNext
    VkImage            image
    VkDeviceMemory     memory
    VkDeviceSize       memoryOffset
}

class VkPhysicalDevice16BitStorageFeatures {
    VkStructureType    sType
    void*              pNext
    VkBool32           storageBuffer16BitAccess
    VkBool32           uniformAndStorageBuffer16BitAccess
    VkBool32           storagePushConstant16
    VkBool32           storageInputOutput16
}

class VkMemoryDedicatedRequirements {
    VkStructureType    sType
    void*              pNext
    VkBool32           prefersDedicatedAllocation
    VkBool32           requiresDedicatedAllocation
}

class VkMemoryDedicatedAllocateInfo {
    VkStructureType    sType
    const void*        pNext
    VkImage            image
    VkBuffer           buffer
}

class VkMemoryAllocateFlagsInfo {
    VkStructureType          sType
    const void*              pNext
    VkMemoryAllocateFlags    flags
    u32                      deviceMask
}

class VkDeviceGroupRenderPassBeginInfo {
    VkStructureType    sType
    const void*        pNext
    u32                deviceMask
    u32                deviceRenderAreaCount
    const VkRect2D*    pDeviceRenderAreas
}

class VkDeviceGroupCommandBufferBeginInfo {
    VkStructureType    sType
    const void*        pNext
    u32                deviceMask
}

class VkDeviceGroupSubmitInfo {
    VkStructureType             sType
    const void*                 pNext
    u32                         waitSemaphoreCount
    const u32*                  pWaitSemaphoreDeviceIndices
    u32                         commandBufferCount
    const u32*                  pCommandBufferDeviceMasks
    u32                         signalSemaphoreCount
    const u32*                  pSignalSemaphoreDeviceIndices
}

class VkDeviceGroupBindSparseInfo {
    VkStructureType    sType
    const void*        pNext
    u32                resourceDeviceIndex
    u32                memoryDeviceIndex
}

class VkBindBufferMemoryDeviceGroupInfo {
    VkStructureType                     sType
    const void*                         pNext
    u32                                 deviceIndexCount
    const u32*                          pDeviceIndices
}

class VkBindImageMemoryDeviceGroupInfo {
    VkStructureType                     sType
    const void*                         pNext
    u32                                 deviceIndexCount
    const u32*                          pDeviceIndices
    u32                                 splitInstanceBindRegionCount
    const VkRect2D*                     pSplitInstanceBindRegions
}

class VkPhysicalDeviceGroupProperties {
    VkStructureType                             sType
    void*                                       pNext
    u32                                         physicalDeviceCount
    VkPhysicalDevice[VK_MAX_DEVICE_GROUP_SIZE]  physicalDevices
    VkBool32                                    subsetAllocation
}

class VkDeviceGroupDeviceCreateInfo {
    VkStructureType            sType
    const void*                pNext
    u32                        physicalDeviceCount
    const VkPhysicalDevice*    pPhysicalDevices
}

class VkBufferMemoryRequirementsInfo2 {
    VkStructureType    sType
    const void*        pNext
    VkBuffer           buffer
}

class VkImageMemoryRequirementsInfo2 {
    VkStructureType    sType
    const void*        pNext
    VkImage            image
}

class VkImageSparseMemoryRequirementsInfo2 {
    VkStructureType    sType
    const void*        pNext
    VkImage            image
}

class VkMemoryRequirements2 {
    VkStructureType         sType
    void*                   pNext
    VkMemoryRequirements    memoryRequirements
}

class VkSparseImageMemoryRequirements2 {
    VkStructureType                    sType
    void*                              pNext
    VkSparseImageMemoryRequirements    memoryRequirements
}

class VkPhysicalDeviceFeatures2 {
    VkStructureType             sType
    void*                       pNext
    VkPhysicalDeviceFeatures    features
}

class VkPhysicalDeviceProperties2 {
    VkStructureType               sType
    void*                         pNext
    VkPhysicalDeviceProperties    properties
}

class VkFormatProperties2 {
    VkStructureType       sType
    void*                 pNext
    VkFormatProperties    formatProperties
}

class VkImageFormatProperties2 {
    VkStructureType            sType
    void*                      pNext
    VkImageFormatProperties    imageFormatProperties
}

class VkPhysicalDeviceImageFormatInfo2 {
    VkStructureType       sType
    const void*           pNext
    VkFormat              format
    VkImageType           type
    VkImageTiling         tiling
    VkImageUsageFlags     usage
    VkImageCreateFlags    flags
}

class VkQueueFamilyProperties2 {
    VkStructureType            sType
    void*                      pNext
    VkQueueFamilyProperties    queueFamilyProperties
}

class VkPhysicalDeviceMemoryProperties2 {
    VkStructureType                     sType
    void*                               pNext
    VkPhysicalDeviceMemoryProperties    memoryProperties
}

class VkSparseImageFormatProperties2 {
    VkStructureType                  sType
    void*                            pNext
    VkSparseImageFormatProperties    properties
}

class VkPhysicalDeviceSparseImageFormatInfo2 {
    VkStructureType          sType
    const void*              pNext
    VkFormat                 format
    VkImageType              type
    VkSampleCountFlagBits    samples
    VkImageUsageFlags        usage
    VkImageTiling            tiling
}

class VkPhysicalDevicePointClippingProperties {
    VkStructureType            sType
    void*                      pNext
    VkPointClippingBehavior    pointClippingBehavior
}

class VkInputAttachmentAspectReference {
    u32                   subpass
    u32                   inputAttachmentIndex
    VkImageAspectFlags    aspectMask
}

class VkRenderPassInputAttachmentAspectCreateInfo {
    VkStructureType                            sType
    const void*                                pNext
    u32                                        aspectReferenceCount
    const VkInputAttachmentAspectReference*    pAspectReferences
}

class VkImageViewUsageCreateInfo {
    VkStructureType      sType
    const void*          pNext
    VkImageUsageFlags    usage
}

class VkPipelineTessellationDomainOriginStateCreateInfo {
    VkStructureType               sType
    const void*                   pNext
    VkTessellationDomainOrigin    domainOrigin
}

class VkRenderPassMultiviewCreateInfo {
    VkStructureType    sType
    const void*        pNext
    u32                subpassCount
    const u32*         pViewMasks
    u32                dependencyCount
    const s32*         pViewOffsets
    u32                correlationMaskCount
    const u32*         pCorrelationMasks
}

class VkPhysicalDeviceMultiviewFeatures {
    VkStructureType    sType
    void*              pNext
    VkBool32           multiview
    VkBool32           multiviewGeometryShader
    VkBool32           multiviewTessellationShader
}

class VkPhysicalDeviceMultiviewProperties {
    VkStructureType    sType
    void*              pNext
    u32                maxMultiviewViewCount
    u32                maxMultiviewInstanceIndex
}

class VkPhysicalDeviceVariablePointerFeatures {
    VkStructureType    sType
    void*              pNext
    VkBool32           variablePointersStorageBuffer
    VkBool32           variablePointers
}

class VkPhysicalDeviceProtectedMemoryFeatures {
    VkStructureType    sType
    void*              pNext
    VkBool32           protectedMemory
}

class VkPhysicalDeviceProtectedMemoryProperties {
    VkStructureType    sType
    void*              pNext
    VkBool32           protectedNoFault
}

class VkDeviceQueueInfo2 {
    VkStructureType             sType
    const void*                 pNext
    VkDeviceQueueCreateFlags    flags
    u32                         queueFamilyIndex
    u32                         queueIndex
}

class VkProtectedSubmitInfo {
    VkStructureType    sType
    const void*        pNext
    VkBool32           protectedSubmit
}

class VkSamplerYcbcrConversionCreateInfo {
    VkStructureType                  sType
    const void*                      pNext
    VkFormat                         format
    VkSamplerYcbcrModelConversion    ycbcrModel
    VkSamplerYcbcrRange              ycbcrRange
    VkComponentMapping               components
    VkChromaLocation                 xChromaOffset
    VkChromaLocation                 yChromaOffset
    VkFilter                         chromaFilter
    VkBool32                         forceExplicitReconstruction
}

class VkSamplerYcbcrConversionInfo {
    VkStructureType             sType
    const void*                 pNext
    VkSamplerYcbcrConversion    conversion
}

class VkBindImagePlaneMemoryInfo {
    VkStructureType          sType
    const void*              pNext
    VkImageAspectFlagBits    planeAspect
}

class VkImagePlaneMemoryRequirementsInfo {
    VkStructureType          sType
    const void*              pNext
    VkImageAspectFlagBits    planeAspect
}

class VkPhysicalDeviceSamplerYcbcrConversionFeatures {
    VkStructureType    sType
    void*              pNext
    VkBool32           samplerYcbcrConversion
}

class VkSamplerYcbcrConversionImageFormatProperties {
    VkStructureType    sType
    void*              pNext
    u32                combinedImageSamplerDescriptorCount
}

class VkDescriptorUpdateTemplateEntry {
    u32                                 dstBinding
    u32                                 dstArrayElement
    u32                                 descriptorCount
    VkDescriptorType                    descriptorType
    platform.size_t                     offset
    platform.size_t                     stride
}

class VkDescriptorUpdateTemplateCreateInfo {
    VkStructureType                           sType
    void*                                     pNext
    VkDescriptorUpdateTemplateCreateFlags     flags
    u32                                       descriptorUpdateEntryCount
    const VkDescriptorUpdateTemplateEntry*    pDescriptorUpdateEntries
    VkDescriptorUpdateTemplateType            templateType
    VkDescriptorSetLayout                     descriptorSetLayout
    VkPipelineBindPoint                       pipelineBindPoint
    VkPipelineLayout                          pipelineLayout
    u32                                       set
}

class VkExternalMemoryProperties {
    VkExternalMemoryFeatureFlags       externalMemoryFeatures
    VkExternalMemoryHandleTypeFlags    exportFromImportedHandleTypes
    VkExternalMemoryHandleTypeFlags    compatibleHandleTypes
}

class VkPhysicalDeviceExternalImageFormatInfo {
    VkStructureType                       sType
    const void*                           pNext
    VkExternalMemoryHandleTypeFlagBits    handleType
}

class VkExternalImageFormatProperties {
    VkStructureType               sType
    void*                         pNext
    VkExternalMemoryProperties    externalMemoryProperties
}

class VkPhysicalDeviceExternalBufferInfo {
    VkStructureType                       sType
    const void*                           pNext
    VkBufferCreateFlags                   flags
    VkBufferUsageFlags                    usage
    VkExternalMemoryHandleTypeFlagBits    handleType
}

class VkExternalBufferProperties {
    VkStructureType               sType
    void*                         pNext
    VkExternalMemoryProperties    externalMemoryProperties
}

class VkPhysicalDeviceIDProperties {
    VkStructureType    sType
    void*              pNext
    u8[VK_UUID_SIZE]   deviceUUID
    u8[VK_UUID_SIZE]   driverUUID
    u8[VK_LUID_SIZE]   deviceLUID
    u32                deviceNodeMask
    VkBool32           deviceLUIDValid
}

class VkExternalMemoryImageCreateInfo {
    VkStructureType                    sType
    const void*                        pNext
    VkExternalMemoryHandleTypeFlags    handleTypes
}

class VkExternalMemoryBufferCreateInfo {
    VkStructureType                    sType
    const void*                        pNext
    VkExternalMemoryHandleTypeFlags    handleTypes
}

class VkExportMemoryAllocateInfo {
    VkStructureType                    sType
    const void*                        pNext
    VkExternalMemoryHandleTypeFlags    handleTypes
}

class VkPhysicalDeviceExternalFenceInfo {
    VkStructureType                      sType
    const void*                          pNext
    VkExternalFenceHandleTypeFlagBits    handleType
}

class VkExternalFenceProperties {
    VkStructureType                   sType
    void*                             pNext
    VkExternalFenceHandleTypeFlags    exportFromImportedHandleTypes
    VkExternalFenceHandleTypeFlags    compatibleHandleTypes
    VkExternalFenceFeatureFlags       externalFenceFeatures
}

class VkExportFenceCreateInfo {
    VkStructureType                   sType
    const void*                       pNext
    VkExternalFenceHandleTypeFlags    handleTypes
}

class VkExportSemaphoreCreateInfo {
    VkStructureType                       sType
    const void*                           pNext
    VkExternalSemaphoreHandleTypeFlags    handleTypes
}

class VkPhysicalDeviceExternalSemaphoreInfo {
    VkStructureType                          sType
    const void*                              pNext
    VkExternalSemaphoreHandleTypeFlagBits    handleType
}

class VkExternalSemaphoreProperties {
    VkStructureType                       sType
    void*                                 pNext
    VkExternalSemaphoreHandleTypeFlags    exportFromImportedHandleTypes
    VkExternalSemaphoreHandleTypeFlags    compatibleHandleTypes
    VkExternalSemaphoreFeatureFlags       externalSemaphoreFeatures
}

class VkPhysicalDeviceMaintenance3Properties {
    VkStructureType    sType
    void*              pNext
    u32                maxPerSetDescriptors
    VkDeviceSize       maxMemoryAllocationSize
}

class VkDescriptorSetLayoutSupport {
    VkStructureType    sType
    void*              pNext
    VkBool32           supported
}

class VkPhysicalDeviceShaderDrawParameterFeatures {
    VkStructureType    sType
    void*              pNext
    VkBool32           shaderDrawParameters
}


@extension("VK_KHR_surface") // 1
class VkSurfaceCapabilitiesKHR {
    u32                                         minImageCount
    u32                                         maxImageCount
    VkExtent2D                                  currentExtent
    VkExtent2D                                  minImageExtent
    VkExtent2D                                  maxImageExtent
    u32                                         maxImageArrayLayers
    VkSurfaceTransformFlagsKHR                  supportedTransforms
    VkSurfaceTransformFlagBitsKHR               currentTransform
    VkCompositeAlphaFlagsKHR                    supportedCompositeAlpha
    VkImageUsageFlags                           supportedUsageFlags
}

@extension("VK_KHR_surface") // 1
class VkSurfaceFormatKHR {
    VkFormat                                    format
    VkColorSpaceKHR                             colorSpace
}

@extension("VK_KHR_swapchain") // 2
class VkSwapchainCreateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkSwapchainCreateFlagsKHR                   flags
    VkSurfaceKHR                                surface
    u32                                         minImageCount
    VkFormat                                    imageFormat
    VkColorSpaceKHR                             imageColorSpace
    VkExtent2D                                  imageExtent
    u32                                         imageArrayLayers
    VkImageUsageFlags                           imageUsage
    VkSharingMode                               sharingMode
    u32                                         queueFamilyIndexCount
    const u32*                                  pQueueFamilyIndices
    VkSurfaceTransformFlagBitsKHR               preTransform
    VkCompositeAlphaFlagBitsKHR                 compositeAlpha
    VkPresentModeKHR                            presentMode
    VkBool32                                    clipped
    VkSwapchainKHR                              oldSwapchain
}

@extension("VK_KHR_swapchain") // 2
class VkPresentInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         waitSemaphoreCount
    const VkSemaphore*                          pWaitSemaphores
    u32                                         swapchainCount
    const VkSwapchainKHR*                       pSwapchains
    const u32*                                  pImageIndices
    VkResult*                                   pResults
}

@vulkan1_1
@extension("VK_KHR_swapchain") // 2
class VkImageSwapchainCreateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkSwapchainKHR                              swapchain
}

@vulkan1_1
@extension("VK_KHR_swapchain") // 2
class VkBindImageMemorySwapchainInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkSwapchainKHR                              swapchain
    u32                                         imageIndex
}

@vulkan1_1
@extension("VK_KHR_swapchain") // 2
class VkAcquireNextImageInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkSwapchainKHR                              swapchain
    u64                                         timeout
    VkSemaphore                                 semaphore
    VkFence                                     fence
    u32                                         deviceMask
}

@vulkan1_1
@extension("VK_KHR_swapchain") // 2
class VkDeviceGroupPresentCapabilitiesKHR {
    VkStructureType                             sType
    const void*                                 pNext
    u32[VK_MAX_DEVICE_GROUP_SIZE]               presentMask
    VkDeviceGroupPresentModeFlagsKHR            modes
}

@vulkan1_1
@extension("VK_KHR_swapchain") // 2
class VkDeviceGroupPresentInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         swapchainCount
    const u32*                                  pDeviceMasks
    VkDeviceGroupPresentModeFlagBitsKHR         mode
}

@vulkan1_1
@extension("VK_KHR_swapchain") // 2
class VkDeviceGroupSwapchainCreateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkDeviceGroupPresentModeFlagsKHR            modes
}

@extension("VK_KHR_display") // 3
class VkDisplayPropertiesKHR {
    VkDisplayKHR                                display
    const char*                                 displayName
    VkExtent2D                                  physicalDimensions
    VkExtent2D                                  physicalResolution
    VkSurfaceTransformFlagsKHR                  supportedTransforms
    VkBool32                                    planeReorderPossible
    VkBool32                                    persistentContent
}

@extension("VK_KHR_display") // 3
class VkDisplayModeParametersKHR {
    VkExtent2D                                  visibleRegion
    u32                                         refreshRate
}

@extension("VK_KHR_display") // 3
class VkDisplayModePropertiesKHR {
    VkDisplayModeKHR                            displayMode
    VkDisplayModeParametersKHR                  parameters
}

@extension("VK_KHR_display") // 3
class VkDisplayModeCreateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkDisplayModeCreateFlagsKHR                 flags
    VkDisplayModeParametersKHR                  parameters
}

@extension("VK_KHR_display") // 3
class VkDisplayPlanePropertiesKHR {
    VkDisplayKHR                                currentDisplay
    u32                                         currentStackIndex
}

@extension("VK_KHR_display") // 3
class VkDisplayPlaneCapabilitiesKHR {
    VkDisplayPlaneAlphaFlagsKHR                 supportedAlpha
    VkOffset2D                                  minSrcPosition
    VkOffset2D                                  maxSrcPosition
    VkExtent2D                                  minSrcExtent
    VkExtent2D                                  maxSrcExtent
    VkOffset2D                                  minDstPosition
    VkOffset2D                                  maxDstPosition
    VkExtent2D                                  minDstExtent
    VkExtent2D                                  maxDstExtent
}

@extension("VK_KHR_display") // 3
class VkDisplaySurfaceCreateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkDisplaySurfaceCreateFlagsKHR              flags
    VkDisplayModeKHR                            displayMode
    u32                                         planeIndex
    u32                                         planeStackIndex
    VkSurfaceTransformFlagBitsKHR               transform
    f32                                         globalAlpha
    VkDisplayPlaneAlphaFlagBitsKHR              alphaMode
    VkExtent2D                                  imageExtent
}

@extension("VK_KHR_display_swapchain") // 4
class VkDisplayPresentInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkRect2D                                    srcRect
    VkRect2D                                    dstRect
    VkBool32                                    persistent
}

@extension("VK_KHR_xlib_surface") // 5
class VkXlibSurfaceCreateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkXlibSurfaceCreateFlagsKHR                 flags
    platform.Display*                           dpy
    platform.Window                             window
}

@extension("VK_KHR_xcb_surface") // 6
class VkXcbSurfaceCreateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkXcbSurfaceCreateFlagsKHR                  flags
    platform.xcb_connection_t*                  connection
    platform.xcb_window_t                       window
}

@extension("VK_KHR_wayland_surface") // 7
class VkWaylandSurfaceCreateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkWaylandSurfaceCreateFlagsKHR              flags
    platform.wl_display*                        display
    platform.wl_surface*                        surface
}

@extension("VK_KHR_mir_surface") // 8
class VkMirSurfaceCreateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkMirSurfaceCreateFlagsKHR                  flags
    platform.MirConnection*                     connection
    platform.MirSurface*                        mirSurface
}

@extension("VK_KHR_android_surface") // 9
class VkAndroidSurfaceCreateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkAndroidSurfaceCreateFlagsKHR              flags
    platform.ANativeWindow*                     window
}

@extension("VK_KHR_win32_surface") // 10
class VkWin32SurfaceCreateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkWin32SurfaceCreateFlagsKHR                flags
    platform.HINSTANCE                          hinstance
    platform.HWND                               hwnd
}

@extension("VK_ANDROID_native_buffer") // 11
@internal class Gralloc1Usage {
    u64                                         consumer
    u64                                         producer
}

@extension("VK_ANDROID_native_buffer") // 11
class VkNativeBufferANDROID {
    VkStructureType                             sType
    const void*                                 pNext
    platform.buffer_handle_t                    handle
    s32                                         stride
    s32                                         format
    s32                                         usage
    Gralloc1Usage                               usage2
}

@extension("VK_ANDROID_native_buffer") // 11
class VkSwapchainImageCreateInfoANDROID {
    VkStructureType                             sType
    const void*                                 pNext
    VkSwapchainImageUsageFlagsANDROID           flags
}

@extension("VK_ANDROID_native_buffer") // 11
class VkPhysicalDevicePresentationPropertiesANDROID {
    VkStructureType                             sType
    void*                                       pNext
    VkBool32                                    sharedImage
}

@extension("VK_EXT_debug_report") // 12
class VkDebugReportCallbackCreateInfoEXT {
    VkStructureType                             sType
    const void*                                 pNext
    VkDebugReportFlagsEXT                       flags
    PFN_vkDebugReportCallbackEXT                pfnCallback
    void*                                       pUserData
}

@extension("VK_AMD_rasterization_order") // 19
class VkPipelineRasterizationStateRasterizationOrderAMD {
    VkStructureType                             sType
    const void*                                 pNext
    VkRasterizationOrderAMD                     rasterizationOrder
}

@extension("VK_EXT_debug_marker") // 23
class VkDebugMarkerObjectNameInfoEXT {
    VkStructureType                             sType
    const void*                                 pNext
    VkDebugReportObjectTypeEXT                  objectType
    u64                                         object
    const char*                                 pObjectName
}

@extension("VK_EXT_debug_marker") // 23
class VkDebugMarkerObjectTagInfoEXT {
    VkStructureType                             sType
    const void*                                 pNext
    VkDebugReportObjectTypeEXT                  objectType
    u64                                         object
    u64                                         tagName
    platform.size_t                             tagSize
    const void*                                 pTag
}

@extension("VK_EXT_debug_marker") // 23
class VkDebugMarkerMarkerInfoEXT {
    VkStructureType                             sType
    const void*                                 pNext
    const char*                                 pMarkerName
    f32[4]                                      color
}

@extension("VK_NV_dedicated_allocation") // 27
class VkDedicatedAllocationImageCreateInfoNV {
    VkStructureType                             sType
    const void*                                 pNext
    VkBool32                                    dedicatedAllocation
}

@extension("VK_NV_dedicated_allocation") // 27
class VkDedicatedAllocationBufferCreateInfoNV {
    VkStructureType                             sType
    const void*                                 pNext
    VkBool32                                    dedicatedAllocation
}

@extension("VK_NV_dedicated_allocation") // 27
class VkDedicatedAllocationMemoryAllocateInfoNV {
    VkStructureType                             sType
    const void*                                 pNext
    VkImage                                     image
    VkBuffer                                    buffer
}

@extension("VK_EXT_transform_feedback") // 29
class VkPhysicalDeviceTransformFeedbackFeaturesEXT {
    VkStructureType                             sType
    void*                                       pNext
    VkBool32                                    transformFeedback
    VkBool32                                    geometryStreams
}

@extension("VK_EXT_transform_feedback") // 29
class VkPhysicalDeviceTransformFeedbackPropertiesEXT {
    VkStructureType                             sType
    void*                                       pNext
    u32                                         maxTransformFeedbackStreams
    u32                                         maxTransformFeedbackBuffers
    VkDeviceSize                                maxTransformFeedbackBufferSize
    u32                                         maxTransformFeedbackStreamDataSize
    u32                                         maxTransformFeedbackBufferDataSize
    u32                                         maxTransformFeedbackBufferDataStride
    VkBool32                                    transformFeedbackQueries
    VkBool32                                    transformFeedbackStreamsLinesTriangles
    VkBool32                                    transformFeedbackRasterizationStreamSelect
    VkBool32                                    transformFeedbackDraw
}

@extension("VK_EXT_transform_feedback") // 29
class VkPipelineRasterizationStateStreamCreateInfoEXT {
    VkStructureType                                     sType
    const void*                                         pNext
    VkPipelineRasterizationStateStreamCreateFlagsEXT    flags
    u32                                                 rasterizationStream
}

@extension("VK_AMD_texture_gather_bias_lod") // 42
class VkTextureLODGatherFormatPropertiesAMD {
    VkStructureType                             sType
    void*                                       pNext
    VkBool32                                    supportsTextureGatherLODBiasAMD
}

@extension("VK_AMD_shader_info") // 43
class VkShaderResourceUsageAMD {
    u32                                         numUsedVgprs
    u32                                         numUsedSgprs
    u32                                         ldsSizePerLocalWorkGroup
    platform.size_t                             ldsUsageSizeInBytes
    platform.size_t                             scratchMemUsageInBytes
}

@extension("VK_AMD_shader_info") // 43
class VkShaderStatisticsInfoAMD {
    VkShaderStageFlags                          shaderStageMask
    VkShaderResourceUsageAMD                    resourceUsage
    u32                                         numPhysicalVgprs
    u32                                         numPhysicalSgprs
    u32                                         numAvailableVgprs
    u32                                         numAvailableSgprs
    u32[3]                                      computeWorkGroupSize
}

@extension("VK_NV_corner_sampled_image") // 51
class VkPhysicalDeviceCornerSampledImageFeaturesNV {
    VkStructureType                             sType
    void*                                       pNext
    VkBool32                                    cornerSampledImage
}

@extension("VK_KHR_multiview") // 54
class VkRenderPassMultiviewCreateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         subpassCount
    const u32*                                  pViewMasks
    u32                                         dependencyCount
    const s32*                                  pViewOffsets
    u32                                         correlationMaskCount
    const u32*                                  pCorrelationMasks
}

@extension("VK_KHR_multiview") // 54
class VkPhysicalDeviceMultiviewFeaturesKHR {
    VkStructureType                             sType
    void*                                       pNext
    VkBool32                                    multiview
    VkBool32                                    multiviewGeometryShader
    VkBool32                                    multiviewTessellationShader
}

@extension("VK_KHR_multiview") // 54
class VkPhysicalDeviceMultiviewPropertiesKHR {
    VkStructureType                             sType
    void*                                       pNext
    u32                                         maxMultiviewViewCount
    u32                                         maxMultiviewInstanceIndex
}

@extension("VK_NV_external_memory_capabilities") // 56
class VkExternalImageFormatPropertiesNV {
    VkImageFormatProperties                     imageFormatProperties
    VkExternalMemoryFeatureFlagsNV              externalMemoryFeatures
    VkExternalMemoryHandleTypeFlagsNV           exportFromImportedHandleTypes
    VkExternalMemoryHandleTypeFlagsNV           compatibleHandleTypes
}

@extension("VK_NV_external_memory") // 57
class VkExternalMemoryImageCreateInfoNV {
    VkStructureType                             sType
    const void*                                 pNext
    VkExternalMemoryHandleTypeFlagsNV           handleTypes
}

@extension("VK_NV_external_memory") // 57
class VkExportMemoryAllocateInfoNV {
    VkStructureType                             sType
    const void*                                 pNext
    VkExternalMemoryHandleTypeFlagsNV           handleTypes
}

@extension("VK_NV_external_memory_win32") // 58
class VkImportMemoryWin32HandleInfoNV {
    VkStructureType                             sType
    const void*                                 pNext
    VkExternalMemoryHandleTypeFlagsNV           handleType
    platform.HANDLE                             handle
}

@extension("VK_NV_external_memory_win32") // 58
class VkExportMemoryWin32HandleInfoNV {
    VkStructureType                             sType
    const void*                                 pNext
    const platform.SECURITY_ATTRIBUTES*         pAttributes
    platform.DWORD                              dwAccess
}

@extension("VK_NV_win32_keyed_mutex") // 59
class VkWin32KeyedMutexAcquireReleaseInfoNV {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         acquireCount
    const VkDeviceMemory*                       pAcquireSyncs
    const u64*                                  pAcquireKeys
    const u32*                                  pAcquireTimeoutMilliseconds
    u32                                         releaseCount
    const VkDeviceMemory*                       pReleaseSyncs
    const u64*                                  pReleaseKeys
}

@extension("VK_KHR_get_physical_device_properties2") // 60
class VkPhysicalDeviceFeatures2KHR {
    VkStructureType                             sType
    void*                                       pNext
    VkPhysicalDeviceFeatures                    features
}

@extension("VK_KHR_get_physical_device_properties2") // 60
class VkPhysicalDeviceProperties2KHR {
    VkStructureType                             sType
    void*                                       pNext
    VkPhysicalDeviceProperties                  properties
}

@extension("VK_KHR_get_physical_device_properties2") // 60
class VkFormatProperties2KHR {
    VkStructureType                             sType
    void*                                       pNext
    VkFormatProperties                          formatProperties
}

@extension("VK_KHR_get_physical_device_properties2") // 60
class VkImageFormatProperties2KHR {
    VkStructureType                             sType
    void*                                       pNext
    VkImageFormatProperties                     imageFormatProperties
}

@extension("VK_KHR_get_physical_device_properties2") // 60
class VkPhysicalDeviceImageFormatInfo2KHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkFormat                                    format
    VkImageType                                 type
    VkImageTiling                               tiling
    VkImageUsageFlags                           usage
    VkImageCreateFlags                          flags
}

@extension("VK_KHR_get_physical_device_properties2") // 60
class VkQueueFamilyProperties2KHR {
    VkStructureType                             sType
    void*                                       pNext
    VkQueueFamilyProperties                     queueFamilyProperties
}

@extension("VK_KHR_get_physical_device_properties2") // 60
class VkPhysicalDeviceMemoryProperties2KHR {
    VkStructureType                             sType
    void*                                       pNext
    VkPhysicalDeviceMemoryProperties            memoryProperties
}

@extension("VK_KHR_get_physical_device_properties2") // 60
class VkSparseImageFormatProperties2KHR {
    VkStructureType                             sType
    void*                                       pNext
    VkSparseImageFormatProperties               properties
}

@extension("VK_KHR_get_physical_device_properties2") // 60
class VkPhysicalDeviceSparseImageFormatInfo2KHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkFormat                                    format
    VkImageType                                 type
    VkSampleCountFlagBits                       samples
    VkImageUsageFlags                           usage
    VkImageTiling                               tiling
}

@extension("VK_KHR_device_group") // 61
class VkMemoryAllocateFlagsInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkMemoryAllocateFlagsKHR                    flags
    u32                                         deviceMask
}

@extension("VK_KHR_device_group") // 61
class VkBindBufferMemoryDeviceGroupInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         deviceIndexCount
    const u32*                                  pDeviceIndices
}

@extension("VK_KHR_device_group") // 61
class VkBindImageMemoryDeviceGroupInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         deviceIndexCount
    const u32*                                  pDeviceIndices
    u32                                         SFRRectCount
    const VkRect2D*                             pSFRRects
}

@extension("VK_KHR_device_group") // 61
class VkDeviceGroupRenderPassBeginInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         deviceMask
    u32                                         deviceRenderAreaCount
    const VkRect2D*                             pDeviceRenderAreas
}

@extension("VK_KHR_device_group") // 61
class VkDeviceGroupCommandBufferBeginInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         deviceMask
}

@extension("VK_KHR_device_group") // 61
class VkDeviceGroupSubmitInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         waitSemaphoreCount
    const u32*                                  pWaitSemaphoreDeviceIndices
    u32                                         commandBufferCount
    const u32*                                  pCommandBufferDeviceMasks
    u32                                         signalSemaphoreCount
    const u32*                                  pSignalSemaphoreDeviceIndices
}

@extension("VK_KHR_device_group") // 61
class VkDeviceGroupBindSparseInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         resourceDeviceIndex
    u32                                         memoryDeviceIndex
}

@extension("VK_EXT_validation_flags") // 62
class VkValidationFlagsEXT {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         disabledValidationCheckCount
    const VkValidationCheckEXT*                 pDisabledValidationChecks
}

@extension("VK_NN_vi_surface") // 63
class VkViSurfaceCreateInfoNN {
    VkStructureType                             sType
    const void*                                 pNext
    VkViSurfaceCreateFlagsNN                    flags
    void*                                       window
}

@extension("VK_EXT_astc_decode_mode") // 68
class VkImageViewASTCDecodeModeEXT {
    VkStructureType                             sType
    const void*                                 pNext
    VkFormat                                    decodeMode
}

@extension("VK_EXT_astc_decode_mode") // 68
class VkPhysicalDeviceASTCDecodeFeaturesEXT {
    VkStructureType                             sType
    void*                                       pNext
    VkBool32                                    decodeModeSharedExponent
}

@extension("VK_KHR_device_group_creation") // 71
class VkPhysicalDeviceGroupPropertiesKHR {
    VkStructureType                                 sType
    void*                                           pNext
    u32                                             physicalDeviceCount
    VkPhysicalDevice[VK_MAX_DEVICE_GROUP_SIZE]      physicalDevices
    VkBool32                                        subsetAllocation
}

@extension("VK_KHR_device_group_creation") // 71
class VkDeviceGroupDeviceCreateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         physicalDeviceCount
    const VkPhysicalDevice*                     pPhysicalDevices
}

@extension("VK_KHR_external_memory_capabilities") // 72
class VkExternalMemoryPropertiesKHR {
    VkExternalMemoryFeatureFlagsKHR             externalMemoryFeatures
    VkExternalMemoryHandleTypeFlagsKHR          exportFromImportedHandleTypes
    VkExternalMemoryHandleTypeFlagsKHR          compatibleHandleTypes
}

@extension("VK_KHR_external_memory_capabilities") // 72
class VkPhysicalDeviceExternalImageFormatInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkExternalMemoryHandleTypeFlagBitsKHR       handleType
}

@extension("VK_KHR_external_memory_capabilities") // 72
class VkExternalImageFormatPropertiesKHR {
    VkStructureType                             sType
    void*                                       pNext
    VkExternalMemoryPropertiesKHR               externalMemoryProperties
}

@extension("VK_KHR_external_memory_capabilities") // 72
class VkPhysicalDeviceExternalBufferInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkBufferCreateFlags                         flags
    VkBufferUsageFlags                          usage
    VkExternalMemoryHandleTypeFlagBitsKHR       handleType
}

@extension("VK_KHR_external_memory_capabilities") // 72
class VkExternalBufferPropertiesKHR {
    VkStructureType                             sType
    void*                                       pNext
    VkExternalMemoryPropertiesKHR               externalMemoryProperties
}

@extension("VK_KHR_external_memory_capabilities") // 72
class VkPhysicalDeviceIDPropertiesKHR {
    VkStructureType                             sType
    void*                                       pNext
    u8[VK_UUID_SIZE]                            deviceUUID
    u8[VK_UUID_SIZE]                            driverUUID
    u8[VK_LUID_SIZE]                            deviceLUID
    u32                                         deviceNodeMask
    VkBool32                                    deviceLUIDValid
}

@extension("VK_KHR_external_memory") // 73
class VkExternalMemoryImageCreateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkExternalMemoryHandleTypeFlagsKHR          handleTypes
}

@extension("VK_KHR_external_memory") // 73
class VkExternalMemoryBufferCreateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkExternalMemoryHandleTypeFlagsKHR          handleTypes
}

@extension("VK_KHR_external_memory") // 73
class VkExportMemoryAllocateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkExternalMemoryHandleTypeFlagsKHR          handleTypes
}

@extension("VK_KHR_external_memory_win32") // 74
class VkImportMemoryWin32HandleInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkExternalMemoryHandleTypeFlagBitsKHR       handleType
    platform.HANDLE                             handle
    platform.LPCWSTR                            name
}

@extension("VK_KHR_external_memory_win32") // 74
class VkExportMemoryWin32HandleInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    const platform.SECURITY_ATTRIBUTES*         pAttributes
    platform.DWORD                              dwAccess
    platform.LPCWSTR                            name
}

@extension("VK_KHR_external_memory_win32") // 74
class VkMemoryWin32HandlePropertiesKHR {
    VkStructureType                             sType
    void*                                       pNext
    u32                                         memoryTypeBits
}

@extension("VK_KHR_external_memory_win32") // 74
class VkMemoryGetWin32HandleInfoKHR {
    VkStructureType                             sType
    void*                                       pNext
    VkDeviceMemory                              memory
    VkExternalMemoryHandleTypeFlagBitsKHR       handleType
}

@extension("VK_KHR_external_memory_fd") // 75
class VkImportMemoryFdInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkExternalMemoryHandleTypeFlagBitsKHR       handleType
    int                                         fd
}

@extension("VK_KHR_external_memory_fd") // 75
class VkMemoryFdPropertiesKHR {
    VkStructureType                             sType
    void*                                       pNext
    u32                                         memoryTypeBits
}

@extension("VK_KHR_external_memory_fd") // 75
class VkMemoryGetFdInfoKHR {
    VkStructureType                             sType
    void*                                       pNext
    VkDeviceMemory                              memory
    VkExternalMemoryHandleTypeFlagBitsKHR       handleType
}

@extension("VK_KHR_win32_keyed_mutex") // 76
class VkWin32KeyedMutexAcquireReleaseInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         acquireCount
    const VkDeviceMemory*                       pAcquireSyncs
    const u64*                                  pAcquireKeys
    const u32*                                  pAcquireTimeouts
    u32                                         releaseCount
    const VkDeviceMemory*                       pReleaseSyncs
    const u64*                                  pReleaseKeys
}

@extension("VK_KHR_external_semaphore_capabilities") // 77
class VkPhysicalDeviceExternalSemaphoreInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType
}

@extension("VK_KHR_external_semaphore_capabilities") // 77
class VkExternalSemaphorePropertiesKHR {
    VkStructureType                             sType
    void*                                       pNext
    VkExternalSemaphoreHandleTypeFlagsKHR       exportFromImportedHandleTypes
    VkExternalSemaphoreHandleTypeFlagsKHR       compatibleHandleTypes
    VkExternalSemaphoreFeatureFlagsKHR          externalSemaphoreFeatures
}

@extension("VK_KHR_external_semaphore") // 78
class VkExportSemaphoreCreateInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkExternalSemaphoreHandleTypeFlagsKHR       handleTypes
}

@extension("VK_KHR_external_semaphore_win32") // 79
class VkImportSemaphoreWin32HandleInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkSemaphore                                 semaphore
    VkSemaphoreImportFlagsKHR                   flags
    VkExternalSemaphoreHandleTypeFlagsKHR       handleType
    platform.HANDLE                             handle
    platform.LPCWSTR                            name
}

@extension("VK_KHR_external_semaphore_win32") // 79
class VkExportSemaphoreWin32HandleInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    const platform.SECURITY_ATTRIBUTES*         pAttributes
    platform.DWORD                              dwAccess
    platform.LPCWSTR                            name
}

@extension("VK_KHR_external_semaphore_win32") // 79
class VkD3D12FenceSubmitInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         waitSemaphoreValuesCount
    const u64*                                  pWaitSemaphoreValues
    u32                                         signalSemaphoreValuesCount
    const u64*                                  pSignalSemaphoreValues
}

@extension("VK_KHR_external_semaphore_win32") // 79
class VkSemaphoreGetWin32HandleInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkSemaphore                                 semaphore
    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType
}

@extension("VK_KHR_external_semaphore_fd") // 80
class VkImportSemaphoreFdInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkSemaphore                                 semaphore
    VkSemaphoreImportFlagsKHR                   flags
    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType
    s32                                         fd
}

@extension("VK_KHR_external_semaphore_fd") // 80
class VkSemaphoreGetFdInfoKHR {
    VkStructureType                             sType
    const void*                                 pNext
    VkSemaphore                                 semaphore
    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType
}

@extension("VK_KHR_push_descriptor") // 81
class VkPhysicalDevicePushDescriptorPropertiesKHR {
    VkStructureType                             sType
    void*                                       pNext
    u32                                         maxPushDescriptors
}

@extension("VK_EXT_conditional_rendering") // 82
class VkConditionalRenderingBeginInfoEXT {
    VkStructureType                             sType
    const void*                                 pNext
    VkBuffer                                    buffer
    VkDeviceSize                                offset
    VkConditionalRenderingFlagsEXT              flags
}

@extension("VK_EXT_conditional_rendering") // 82
class VkPhysicalDeviceConditionalRenderingFeaturesEXT {
    VkStructureType                             sType
    void*                                       pNext
    VkBool32                                    conditionalRendering
    VkBool32                                    inheritedConditionalRendering
}

@extension("VK_EXT_conditional_rendering") // 82
class VkCommandBufferInheritanceConditionalRenderingInfoEXT {
    VkStructureType                             sType
    const void*                                 pNext
    VkBool32                                    conditionalRenderingEnable
}

@extension("VK_KHR_16bit_storage") // 84
class VkPhysicalDevice16BitStorageFeaturesKHR {
    VkStructureType                             sType
    void*                                       pNext
    VkBool32                                    storageBuffer16BitAccess
    VkBool32                                    uniformAndStorageBuffer16BitAccess
    VkBool32                                    storagePushConstant16
    VkBool32                                    storageInputOutput16
}

@extension("VK_KHR_incremental_present") // 85
class VkRectLayerKHR {
    VkOffset2D                                  offset
    VkExtent2D                                  extent
    u32                                         layer
}

@extension("VK_KHR_incremental_present") // 85
class VkPresentRegionKHR {
    u32                                         rectangleCount
    const VkRectLayerKHR*                       pRectangles
}

@extension("VK_KHR_incremental_present") // 85
class VkPresentRegionsKHR {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         swapchainCount
    const VkPresentRegionKHR*                   pRegions
}

@extension("VK_KHR_descriptor_update_template") // 86
class VkDescriptorUpdateTemplateEntryKHR {
    u32                                         dstBinding
    u32                                         dstArrayElement
    u32                                         descriptorCount
    VkDescriptorType                            descriptorType
    platform.size_t                             offset
    platform.size_t                             stride
}

@extension("VK_KHR_descriptor_update_template") // 86
class VkDescriptorUpdateTemplateCreateInfoKHR {
    VkStructureType                              sType
    void*                                        pNext
    VkDescriptorUpdateTemplateCreateFlagsKHR     flags
    u32                                          descriptorUpdateEntryCount
    const VkDescriptorUpdateTemplateEntryKHR*    pDescriptorUpdateEntries
    VkDescriptorUpdateTemplateTypeKHR            templateType
    VkDescriptorSetLayout                        descriptorSetLayout
    VkPipelineBindPoint                          pipelineBindPoint
    VkPipelineLayout                             pipelineLayout
    u32                                          set
}

@extension("VK_NVX_device_generated_commands") // 87
class VkDeviceGeneratedCommandsFeaturesNVX {
    VkStructureType                             sType
    const void*                                 pNext
    VkBool32                                    computeBindingPointSupport
}

@extension("VK_NVX_device_generated_commands") // 87
class VkDeviceGeneratedCommandsLimitsNVX {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         maxIndirectCommandsLayoutTokenCount
    u32                                         maxObjectEntryCounts
    u32                                         minSequenceCountBufferOffsetAlignment
    u32                                         minSequenceIndexBufferOffsetAlignment
    u32                                         minCommandsTokenBufferOffsetAlignment
}

@extension("VK_NVX_device_generated_commands") // 87
class VkIndirectCommandsTokenNVX {
    VkIndirectCommandsTokenTypeNVX              tokenType
    VkBuffer                                    buffer
    VkDeviceSize                                offset
}

@extension("VK_NVX_device_generated_commands") // 87
class VkIndirectCommandsLayoutTokenNVX {
    VkIndirectCommandsTokenTypeNVX              tokenType
    u32                                         bindingUnit
    u32                                         dynamicCount
    u32                                         divisor
}

@extension("VK_NVX_device_generated_commands") // 87
class VkIndirectCommandsLayoutCreateInfoNVX {
    VkStructureType                             sType
    const void*                                 pNext
    VkPipelineBindPoint                         pipelineBindPoint
    VkIndirectCommandsLayoutUsageFlagsNVX       flags
    u32                                         tokenCount
    const VkIndirectCommandsLayoutTokenNVX*     pTokens
}

@extension("VK_NVX_device_generated_commands") // 87
class VkCmdProcessCommandsInfoNVX {
    VkStructureType                             sType
    const void*                                 pNext
    VkObjectTableNVX                            objectTable
    VkIndirectCommandsLayoutNVX                 indirectCommandsLayout
    u32                                         indirectCommandsTokenCount
    const VkIndirectCommandsTokenNVX*           pIndirectCommandsTokens
    u32                                         maxSequencesCount
    VkCommandBuffer                             targetCommandBuffer
    VkBuffer                                    sequencesCountBuffer
    VkDeviceSize                                sequencesCountOffset
    VkBuffer                                    sequencesIndexBuffer
    VkDeviceSize                                sequencesIndexOffset
}

@extension("VK_NVX_device_generated_commands") // 87
class VkCmdReserveSpaceForCommandsInfoNVX {
    VkStructureType                             sType
    const void*                                 pNext
    VkObjectTableNVX                            objectTable
    VkIndirectCommandsLayoutNVX                 indirectCommandsLayout
    u32                                         maxSequencesCount
}

@extension("VK_NVX_device_generated_commands") // 87
class VkObjectTableCreateInfoNVX {
    VkStructureType                             sType
    const void*                                 pNext
    u32                                         objectCount
    const VkObjectEntryTypeNVX*                 pObjectEntryTypes
    const u32*                                  pObjectEntryCounts
    const VkObjectEntryUsageFlagsNVX*           pObjectEntryUsageFlags
    u32                                         maxUniformBuffersPerDescriptor
    u32                                         maxStorageBuffersPerDescriptor
    u32                                         maxStorageImagesPerDescriptor
    u32                                         maxSampledImagesPerDescriptor
    u32                                         maxPipelineLayouts
}

@extension("VK_NVX_device_generated_commands") // 87
class VkObjectTableEntryNVX {
    VkObjectEntryTypeNVX                        type
    VkObjectEntryUsageFlagsNVX                  flags
}

@extension("VK_NVX_device_generated_commands") // 87
class VkObjectTablePipelineEntryNVX {
    VkObjectEntryTypeNVX                        type
    VkObjectEntryUsageFlagsNVX                  flags
    VkPipeline                                  pipeline
}

@extension("VK_NVX_device_generated_commands") // 87
class VkObjectTableDescriptorSetEntryNVX {
    VkObjectEntryTypeNVX                        type
    VkObjectEntryUsageFlagsNVX                  flags
    VkPipelineLayout                            pipelineLayout
    VkDescriptorSet                             descriptorSet
}

@extension("VK_NVX_device_generated_commands") // 87
class VkObjectTableVertexBufferEntryNVX {
    VkObjectEntryTypeNVX                        type
    VkObjectEntryUsageFlagsNVX                  flags
    VkBuffer                                    buffer
}

@extension("VK_NVX_device_generated_commands") // 87
class VkObjectTableIndexBufferEntryNVX {
    VkObjectEntryTypeNVX                        type
    VkObjectEntryUsageFlagsNVX                  flags
    VkBuffer                                    buffer
    VkIndexType                                 indexType
}

@extension("VK_NVX_device_generated_commands") // 87
class VkObjectTablePushConstantEntryNVX {
    VkObjectEntryTypeNVX                        type
    VkObjectEntryUsageFlagsNVX                  flags
    VkPipelineLayout                            pipelineLayout
    VkShaderStageFlags                          stageFlags
}

@extension("VK_NV_clip_space_w_scaling") // 88
class VkViewportWScalingNV {
    f32                                         xcoeff
    f32                                         ycoeff
}

@extension("VK_NV_clip_space_w_scaling") // 88
class VkPipelineViewportWScalingStateCreateInfoNV {
    VkStructureType                             sType
    const void*                                 pNext
    VkBool32                                    viewportWScalingEnable
    u32                                         viewportCount
    const VkViewportWScalingNV*                 pViewportWScalings
}

@extension("VK_EXT_display_surface_counter") // 91
class VkSurfaceCapabilities2EXT {
    VkStructureType                             sType
    void*                                       pNext
    u32                                         minImageCount
    u32                                         maxImageCount
    VkExtent2D                                  currentExtent
    VkExtent2D                                  minImageExtent
    VkExtent2D                                  maxImageExtent
    u32                                         maxImageArrayLayers
    VkSurfaceTransformFlagsKHR                  supportedTransforms
    VkSurfaceTransformFlagBitsKHR               currentTransform
    VkCompositeAlphaFlagsKHR                    supportedCompositeAlpha
    VkImageUsageFlags                           supportedUsageFlags
    VkSurfaceCounterFlagsEXT                    supportedSurfaceCounters
}

@extension("VK_EXT_display_control") // 92
class VkDisplayPowerInfoEXT {
    VkStructureType                             sType
    const void*                                 pNext
    VkDisplayPowerStateEXT                      powerState
}

@extension("VK_EXT_display_control") // 92
class VkDeviceEventInfoEXT {
    VkStructureType                             sType
    const void*                                 pNext
    VkDeviceEventTypeEXT                        deviceEvent
}

@extension("VK_EXT_display_control") // 92
class VkDisplayEventInfoEXT {
    VkStructureType                             sType
    const void*                                 pNext
    VkDisplayEventTypeEXT                       displayEvent
}

@extension("VK_EXT_display_control") // 92
class VkSwapchainCounterCreateInfoEXT {
    VkStructureType                             sType
    const void*                                 pNext
    VkSurfaceCounterFlagsEXT                    surfaceCounters
}

@extension("VK_GOOGLE_display_timing") // 93
class VkRefreshCycleDurationGOOGLE {
    u64                                             refreshDuration
}

@extension("VK_GOOGLE_display_timing") // 93
class VkPastPresentationTimingGOOGLE {
    u32                                             presentID
    u64                                             desiredPresentTime
    u64                                             actualPresentTime
    u64                                             earliestPresentTime
    u64                                             presentMargin
}

@extension("VK_GOOGLE_display_timing") // 93
class VkPresentTimeGOOGLE {
    u32                                             presentID
    u64                                             desiredPresentTime
}

@extension("VK_GOOGLE_display_timing") // 93
class VkPresentTimesInfoGOOGLE {
    VkStructureType                                 sType
    const void*                                     pNext
    u32                                             swapchainCount
    const VkPresentTimeGOOGLE*                      pTimes
}

@extension("VK_NVX_multiview_per_view_attributes") // 98
class VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
    VkStructureType                             sType
    void*                                       pNext
    VkBool32                                    perViewPositionAllComponents
}

@extension("VK_NV_viewport_swizzle") // 99
class VkViewportSwizzleNV {
    VkViewportCoordinateSwizzleNV               x
    VkViewportCoordinateSwizzleNV               y
    VkViewportCoordinateSwizzleNV               z
    VkViewportCoordinateSwizzleNV               w
}

@extension("VK_NV_viewport_swizzle") // 99
class VkPipelineViewportSwizzleStateCreateInfoNV {
    VkStructureType                             sType
    const void*                                 pNext
    VkPipelineViewportSwizzleStateCreateFlagsNV flags
    u32                                         viewportCount
    const VkViewportSwizzleNV*                  pViewportSwizzles
}

@extension("VK_EXT_discard_rectangles") // 100
class VkPhysicalDeviceDiscardRectanglePropertiesEXT {
    VkStructureType                             sType
    void*                                       pNext
    u32                                         maxDiscardRectangles
}

@extension("VK_EXT_discard_rectangles") // 100
class VkPipelineDiscardRectangleStateCreateInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    VkPipelineDiscardRectangleStateCreateFlagsEXT   flags
    VkDiscardRectangleModeEXT                       discardRectangleMode
    u32                                             discardRectangleCount
    const VkRect2D*                                 pDiscardRectangles
}

@extension("VK_EXT_conservative_rasterization") // 102
class VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
    VkStructureType                                 sType
    void*                                           pNext
    f32                                             primitiveOverestimationSize
    f32                                             maxExtraPrimitiveOverestimationSize
    f32                                             extraPrimitiveOverestimationSizeGranularity
    VkBool32                                        primitiveUnderestimation
    VkBool32                                        conservativePointAndLineRasterization
    VkBool32                                        degenerateTrianglesRasterized
    VkBool32                                        degenerateLinesRasterized
    VkBool32                                        fullyCoveredFragmentShaderInputVariable
    VkBool32                                        conservativeRasterizationPostDepthCoverage
}

@extension("VK_EXT_conservative_rasterization") // 102
class VkPipelineRasterizationConservativeStateCreateInfoEXT {
    VkStructureType                                           sType
    const void*                                               pNext
    VkPipelineRasterizationConservativeStateCreateFlagsEXT    flags
    VkConservativeRasterizationModeEXT                        conservativeRasterizationMode
    f32                                                       extraPrimitiveOverestimationSize
}

@extension("VK_EXT_hdr_metadata") // 106
class VkXYColorEXT {
    f32                                             x
    f32                                             y
}

@extension("VK_EXT_hdr_metadata") // 106
class VkHdrMetadataEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    VkXYColorEXT                                    displayPrimaryRed
    VkXYColorEXT                                    displayPrimaryGreen
    VkXYColorEXT                                    displayPrimaryBlue
    VkXYColorEXT                                    whitePoint
    f32                                             maxLuminance
    f32                                             minLuminance
    f32                                             maxContentLightLevel
    f32                                             maxFrameAverageLightLevel
}

@extension("VK_KHR_create_renderpass2") // 110
class VkAttachmentDescription2KHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkAttachmentDescriptionFlags                    flags
    VkFormat                                        format
    VkSampleCountFlagBits                           samples
    VkAttachmentLoadOp                              loadOp
    VkAttachmentStoreOp                             storeOp
    VkAttachmentLoadOp                              stencilLoadOp
    VkAttachmentStoreOp                             stencilStoreOp
    VkImageLayout                                   initialLayout
    VkImageLayout                                   finalLayout
}

@extension("VK_KHR_create_renderpass2") // 110
class VkAttachmentReference2KHR {
    VkStructureType                                 sType
    const void*                                     pNext
    u32                                             attachment
    VkImageLayout                                   layout
    VkImageAspectFlags                              aspectMask
}

@extension("VK_KHR_create_renderpass2") // 110
class VkSubpassDescription2KHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkSubpassDescriptionFlags                       flags
    VkPipelineBindPoint                             pipelineBindPoint
    u32                                             viewMask
    u32                                             inputAttachmentCount
    const VkAttachmentReference2KHR*                pInputAttachments
    u32                                             colorAttachmentCount
    const VkAttachmentReference2KHR*                pColorAttachments
    const VkAttachmentReference2KHR*                pResolveAttachments
    const VkAttachmentReference2KHR*                pDepthStencilAttachment
    u32                                             preserveAttachmentCount
    const u32*                                      pPreserveAttachments
}

@extension("VK_KHR_create_renderpass2") // 110
class VkSubpassDependency2KHR {
    VkStructureType                                 sType
    const void*                                     pNext
    u32                                             srcSubpass
    u32                                             dstSubpass
    VkPipelineStageFlags                            srcStageMask
    VkPipelineStageFlags                            dstStageMask
    VkAccessFlags                                   srcAccessMask
    VkAccessFlags                                   dstAccessMask
    VkDependencyFlags                               dependencyFlags
    s32                                             viewOffset
}

@extension("VK_KHR_create_renderpass2") // 110
class VkRenderPassCreateInfo2KHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkRenderPassCreateFlags                         flags
    u32                                             attachmentCount
    const VkAttachmentDescription2KHR*              pAttachments
    u32                                             subpassCount
    const VkSubpassDescription2KHR*                 pSubpasses
    u32                                             dependencyCount
    const VkSubpassDependency2KHR*                  pDependencies
    u32                                             correlatedViewMaskCount
    const u32*                                      pCorrelatedViewMasks
}

@extension("VK_KHR_create_renderpass2") // 110
class VkSubpassBeginInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkSubpassContents                               contents
}

@extension("VK_KHR_create_renderpass2") // 110
class VkSubpassEndInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
}

@extension("VK_KHR_shared_presentable_image") // 112
class VkSharedPresentSurfaceCapabilitiesKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkImageUsageFlags                               sharedPresentSupportedUsageFlags
}

@extension("VK_KHR_external_fence_capabilities") // 113
class VkPhysicalDeviceExternalFenceInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkExternalFenceHandleTypeFlagBitsKHR            handleType
}

@extension("VK_KHR_external_fence_capabilities") // 113
class VkExternalFencePropertiesKHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkExternalFenceHandleTypeFlagsKHR               exportFromImportedHandleTypes
    VkExternalFenceHandleTypeFlagsKHR               compatibleHandleTypes
    VkExternalFenceFeatureFlagsKHR                  externalFenceFeatures
}

@extension("VK_KHR_external_fence") // 114
class VkExportFenceCreateInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkExternalFenceHandleTypeFlagsKHR               handleTypes
}

@extension("VK_KHR_external_fence_win32") // 115
class VkImportFenceWin32HandleInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkFence                                         fence
    VkFenceImportFlagsKHR                           flags
    VkExternalFenceHandleTypeFlagBitsKHR            handleType
    platform.HANDLE                                 handle
    platform.LPCWSTR                                name
}

@extension("VK_KHR_external_fence_win32") // 115
class VkExportFenceWin32HandleInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    const platform.SECURITY_ATTRIBUTES*             pAttributes
    platform.DWORD                                  dwAccess
    platform.LPCWSTR                                name
}

@extension("VK_KHR_external_fence_win32") // 115
class VkFenceGetWin32HandleInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkFence                                         fence
    VkExternalFenceHandleTypeFlagBitsKHR            handleType
}

@extension("VK_KHR_external_fence_fd") // 116
class VkImportFenceFdInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkFence                                         fence
    VkFenceImportFlagsKHR                           flags
    VkExternalFenceHandleTypeFlagBitsKHR            handleType
    int                                             fd
}

@extension("VK_KHR_external_fence_fd") // 116
class VkFenceGetFdInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkFence                                         fence
    VkExternalFenceHandleTypeFlagBitsKHR            handleType
}

@extension("VK_KHR_maintenance2") // 118
class VkPhysicalDevicePointClippingPropertiesKHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkPointClippingBehaviorKHR                      pointClippingBehavior
}

@extension("VK_KHR_maintenance2") // 118
class VkInputAttachmentAspectReferenceKHR {
    u32                                             subpass
    u32                                             inputAttachmentIndex
    VkImageAspectFlags                              aspectMask
}

@extension("VK_KHR_maintenance2") // 118
class VkRenderPassInputAttachmentAspectCreateInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    u32                                             aspectReferenceCount
    const VkInputAttachmentAspectReferenceKHR*      pAspectReferences
}

@extension("VK_KHR_maintenance2") // 118
class VkImageViewUsageCreateInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkImageUsageFlags                               usage
}

@extension("VK_KHR_maintenance2") // 118
class VkPipelineTessellationDomainOriginStateCreateInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkTessellationDomainOriginKHR                   domainOrigin
}

@extension("VK_KHR_get_surface_capabilities2") // 120
class VkPhysicalDeviceSurfaceInfo2KHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkSurfaceKHR                                    surface
}

@extension("VK_KHR_get_surface_capabilities2") // 120
class VkSurfaceCapabilities2KHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkSurfaceCapabilitiesKHR                        surfaceCapabilities
}

@extension("VK_KHR_get_surface_capabilities2") // 120
class VkSurfaceFormat2KHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkSurfaceFormatKHR                              surfaceFormat
}

@extension("VK_KHR_variable_pointers") // 121
class VkPhysicalDeviceVariablePointerFeaturesKHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        variablePointersStorageBuffer
    VkBool32                                        variablePointers
}

@extension("VK_KHR_display_properties2") // 122
class VkDisplayProperties2KHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkDisplayPropertiesKHR                          displayProperties
}

@extension("VK_KHR_display_properties2") // 122
class VkDisplayPlaneProperties2KHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkDisplayPlanePropertiesKHR                     displayPlaneProperties
}

@extension("VK_KHR_display_properties2") // 122
class VkDisplayModeProperties2KHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkDisplayModePropertiesKHR                      displayModeProperties
}

@extension("VK_KHR_display_properties2") // 122
class VkDisplayPlaneInfo2KHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkDisplayModeKHR                                mode
    u32                                             planeIndex
}

@extension("VK_KHR_display_properties2") // 122
class VkDisplayPlaneCapabilities2KHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkDisplayPlaneCapabilitiesKHR                   capabilities
}

@extension("VK_MVK_ios_surface") // 123
class VkIOSSurfaceCreateInfoMVK {
    VkStructureType                                 sType
    const void*                                     pNext
    VkIOSSurfaceCreateFlagsMVK                      flags
    const void*                                     pView
}

@extension("VK_MVK_macos_surface") // 124
class VkMacOSSurfaceCreateInfoMVK {
    VkStructureType                                 sType
    const void*                                     pNext
    VkMacOSSurfaceCreateFlagsMVK                    flags
    const void*                                     pView
}

@extension("VK_KHR_dedicated_allocation") // 128
class VkMemoryDedicatedRequirementsKHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        prefersDedicatedAllocation
    VkBool32                                        requiresDedicatedAllocation
}

@extension("VK_KHR_dedicated_allocation") // 128
class VkMemoryDedicatedAllocateInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkImage                                         image
    VkBuffer                                        buffer
}

@extension("VK_EXT_debug_utils") // 129
class VkDebugUtilsObjectNameInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    VkObjectType                                    objectType
    u64                                             objectHandle
    const char*                                     pObjectName
}

@extension("VK_EXT_debug_utils") // 129
class VkDebugUtilsObjectTagInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    VkObjectType                                    objectType
    u64                                             objectHandle
    u64                                             tagName
    platform.size_t                                 tagSize
    const void*                                     pTag
}

@extension("VK_EXT_debug_utils") // 129
class VkDebugUtilsLabelEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    const char*                                     pLabelName
    f32[4]                                          color
}

@extension("VK_EXT_debug_utils") // 129
class VkDebugUtilsMessengerCallbackDataEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    VkDebugUtilsMessengerCallbackDataFlagsEXT       flags
    const char*                                     pMessageIdName
    s32                                             messageIdNumber
    const char*                                     pMessage
    u32                                             queueLabelCount
    VkDebugUtilsLabelEXT*                           pQueueLabels
    u32                                             cmdBufLabelCount
    VkDebugUtilsLabelEXT*                           pCmdBufLabels
    u32                                             objectCount
    VkDebugUtilsObjectNameInfoEXT*                  pObjects
}

@extension("VK_EXT_debug_utils") // 129
class VkDebugUtilsMessengerCreateInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    VkDebugUtilsMessengerCreateFlagsEXT             flags
    VkDebugUtilsMessageSeverityFlagsEXT             messageSeverity
    VkDebugUtilsMessageTypeFlagsEXT                 messageTypes
    PFN_vkDebugUtilsMessengerCallbackEXT            pfnUserCallback
    void*                                           pUserData
}

@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 131
class VkAndroidHardwareBufferUsageANDROID {
    VkStructureType                                 sType
    void*                                           pNext
    u64                                             androidHardwareBufferUsage
}

@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
class VkAndroidHardwareBufferPropertiesANDROID {
    VkStructureType                                 sType
    void*                                           pNext
    VkDeviceSize                                    allocationSize
    u32                                             memoryTypeBits
}

@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
class VkAndroidHardwareBufferFormatPropertiesANDROID {
    VkStructureType                                 sType
    void*                                           pNext
    VkFormat                                        format
    u64                                             externalFormat
    VkFormatFeatureFlags                            formatFeatures
    VkComponentMapping                              samplerYcbcrConversionComponents
    VkSamplerYcbcrModelConversion                   suggestedYcbcrModel
    VkSamplerYcbcrRange                             suggestedYcbcrRange
    VkChromaLocation                                suggestedXChromaOffset
    VkChromaLocation                                suggestedYChromaOffset
}

@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
class VkImportAndroidHardwareBufferInfoANDROID {
    VkStructureType                                 sType
    const void*                                     pNext
    platform.AHardwareBuffer*                       buffer
}

@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
class VkMemoryGetAndroidHardwareBufferInfoANDROID {
    VkStructureType                                 sType
    const void*                                     pNext
    VkDeviceMemory                                  memory
}

@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
class VkExternalFormatANDROID {
    VkStructureType                                 sType
    void*                                           pNext
    u64                                             externalFormat
}

@extension("VK_EXT_sampler_filter_minmax") // 131
class VkSamplerReductionModeCreateInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    VkSamplerReductionModeEXT                       reductionMode
}

@extension("VK_EXT_sampler_filter_minmax") // 131
class VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        filterMinmaxSingleComponentFormats
    VkBool32                                        filterMinmaxImageComponentMapping
}

@extension("VK_EXT_inline_uniform_block") // 139
class VkPhysicalDeviceInlineUniformBlockFeaturesEXT {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        inlineUniformBlock
    VkBool32                                        descriptorBindingInlineUniformBlockUpdateAfterBind
}

@extension("VK_EXT_inline_uniform_block") // 139
class VkPhysicalDeviceInlineUniformBlockPropertiesEXT {
    VkStructureType                                 sType
    void*                                           pNext
    u32                                             maxInlineUniformBlockSize
    u32                                             maxPerStageDescriptorInlineUniformBlocks
    u32                                             maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks
    u32                                             maxDescriptorSetInlineUniformBlocks
    u32                                             maxDescriptorSetUpdateAfterBindInlineUniformBlocks
}

@extension("VK_EXT_inline_uniform_block") // 139
class VkWriteDescriptorSetInlineUniformBlockEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    u32                                             dataSize
    const void*                                     pData
}

@extension("VK_EXT_inline_uniform_block") // 139
class VkDescriptorPoolInlineUniformBlockCreateInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    u32                                             maxInlineUniformBlockBindings
}

@extension("VK_EXT_sample_locations") // 144
class VkSampleLocationEXT {
    f32                                             x
    f32                                             y
}

@extension("VK_EXT_sample_locations") // 144
class VkSampleLocationsInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    VkSampleCountFlagBits                           sampleLocationsPerPixel
    VkExtent2D                                      sampleLocationGridSize
    u32                                             sampleLocationsCount
    const VkSampleLocationEXT*                      pSampleLocations
}

@extension("VK_EXT_sample_locations") // 144
class VkAttachmentSampleLocationsEXT {
    u32                                             attachmentIndex
    VkSampleLocationsInfoEXT                        sampleLocationsInfo
}

@extension("VK_EXT_sample_locations") // 144
class VkSubpassSampleLocationsEXT {
    u32                                             subpassIndex
    VkSampleLocationsInfoEXT                        sampleLocationsInfo
}

@extension("VK_EXT_sample_locations") // 144
class VkRenderPassSampleLocationsBeginInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    u32                                             attachmentInitialSampleLocationsCount
    const VkAttachmentSampleLocationsEXT*           pAttachmentInitialSampleLocations
    u32                                             postSubpassSampleLocationsCount
    const VkSubpassSampleLocationsEXT*              pPostSubpassSampleLocations
}

@extension("VK_EXT_sample_locations") // 144
class VkPipelineSampleLocationsStateCreateInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    VkBool32                                        sampleLocationsEnable
    VkSampleLocationsInfoEXT                        sampleLocationsInfo
}

@extension("VK_EXT_sample_locations") // 144
class VkPhysicalDeviceSampleLocationsPropertiesEXT {
    VkStructureType                                 sType
    void*                                           pNext
    VkSampleCountFlags                              sampleLocationSampleCounts
    VkExtent2D                                      maxSampleLocationGridSize
    f32[2]                                          sampleLocationCoordinateRange
    u32                                             sampleLocationSubPixelBits
    VkBool32                                        variableSampleLocations
}

@extension("VK_EXT_sample_locations") // 144
class VkMultisamplePropertiesEXT {
    VkStructureType                                 sType
    void*                                           pNext
    VkExtent2D                                      maxSampleLocationGridSize
}

@extension("VK_KHR_get_memory_requirements2") // 147
class VkBufferMemoryRequirementsInfo2KHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkBuffer                                        buffer
}

@extension("VK_KHR_get_memory_requirements2") // 147
class VkImageMemoryRequirementsInfo2KHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkImage                                         image
}

@extension("VK_KHR_get_memory_requirements2") // 147
class VkImageSparseMemoryRequirementsInfo2KHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkImage                                         image
}

@extension("VK_KHR_get_memory_requirements2") // 147
class VkMemoryRequirements2KHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkMemoryRequirements                            memoryRequirements
}

@extension("VK_KHR_get_memory_requirements2") // 147
class VkSparseImageMemoryRequirements2KHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkSparseImageMemoryRequirements                 memoryRequirements
}

@extension("VK_KHR_image_format_list") // 148
class VkImageFormatListCreateInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    u32                                             viewFormatCount
    const VkFormat*                                 pViewFormats
}

@extension("VK_EXT_blend_operation_advanced") // 149
class VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        advancedBlendCoherentOperations
}

@extension("VK_EXT_blend_operation_advanced") // 149
class VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
    VkStructureType                                 sType
    void*                                           pNext
    u32                                             advancedBlendMaxColorAttachments
    VkBool32                                        advancedBlendIndependentBlend
    VkBool32                                        advancedBlendNonPremultipliedSrcColor
    VkBool32                                        advancedBlendNonPremultipliedDstColor
    VkBool32                                        advancedBlendCorrelatedOverlap
    VkBool32                                        advancedBlendAllOperations
}

@extension("VK_EXT_blend_operation_advanced") // 149
class VkPipelineColorBlendAdvancedStateCreateInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    VkBool32                                        srcPremultiplied
    VkBool32                                        dstPremultiplied
    VkBlendOverlapEXT                               blendOverlap
}

@extension("VK_NV_fragment_coverage_to_color") // 150
class VkPipelineCoverageToColorStateCreateInfoNV {
    VkStructureType                                 sType
    const void*                                     pNext
    VkPipelineCoverageToColorStateCreateFlagsNV     flags
    VkBool32                                        coverageToColorEnable
    u32                                             coverageToColorLocation
}

@extension("VK_NV_framebuffer_mixed_samples") // 153
class VkPipelineCoverageModulationStateCreateInfoNV {
    VkStructureType                                 sType
    const void*                                     pNext
    VkPipelineCoverageModulationStateCreateFlagsNV  flags
    VkCoverageModulationModeNV                      coverageModulationMode
    VkBool32                                        coverageModulationTableEnable
    u32                                             coverageModulationTableCount
    const f32*                                      pCoverageModulationTable
}

@extension("VK_KHR_sampler_ycbcr_conversion") // 157
class VkSamplerYcbcrConversionCreateInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkFormat                                        format
    VkSamplerYcbcrModelConversionKHR                ycbcrModel
    VkSamplerYcbcrRangeKHR                          ycbcrRange
    VkComponentMapping                              components
    VkChromaLocationKHR                             xChromaOffset
    VkChromaLocationKHR                             yChromaOffset
    VkFilter                                        chromaFilter
    VkBool32                                        forceExplicitReconstruction
}

@extension("VK_KHR_sampler_ycbcr_conversion") // 157
class VkSamplerYcbcrConversionInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkSamplerYcbcrConversionKHR                     conversion
}

@extension("VK_KHR_sampler_ycbcr_conversion") // 157
class VkBindImagePlaneMemoryInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkImageAspectFlagBits                           planeAspect
}

@extension("VK_KHR_sampler_ycbcr_conversion") // 157
class VkImagePlaneMemoryRequirementsInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkImageAspectFlagBits                           planeAspect
}

@extension("VK_KHR_sampler_ycbcr_conversion") // 157
class VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        samplerYcbcrConversion
}

@extension("VK_KHR_sampler_ycbcr_conversion") // 157
class VkSamplerYcbcrConversionImageFormatPropertiesKHR {
    VkStructureType                                 sType
    void*                                           pNext
    u32                                             combinedImageSamplerDescriptorCount
}

@extension("VK_KHR_bind_memory2") // 158
class VkBindBufferMemoryInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkBuffer                                        buffer
    VkDeviceMemory                                  memory
    VkDeviceSize                                    memoryOffset
}

@extension("VK_KHR_bind_memory2") // 158
class VkBindImageMemoryInfoKHR {
    VkStructureType                                 sType
    const void*                                     pNext
    VkImage                                         image
    VkDeviceMemory                                  memory
    VkDeviceSize                                    memoryOffset
}

@extension("VK_EXT_image_drm_format_modifier") // 159
class VkDrmFormatModifierPropertiesEXT {
    u64                                             drmFormatModifier
    u32                                             drmFormatModifierPlaneCount
    VkFormatFeatureFlags                            drmFormatModifierTilingFeatures
}

@extension("VK_EXT_image_drm_format_modifier") // 159
class VkDrmFormatModifierPropertiesListEXT {
    VkStructureType                                 sType
    void*                                           pNext
    u32                                             drmFormatModifierCount
    VkDrmFormatModifierPropertiesEXT*               pDrmFormatModifierProperties
}

@extension("VK_EXT_image_drm_format_modifier") // 159
class VkPhysicalDeviceImageDrmFormatModifierInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    u64                                             drmFormatModifier
    VkSharingMode                                   sharingMode
    u32                                             queueFamilyIndexCount
    const u32*                                      pQueueFamilyIndices
}

@extension("VK_EXT_image_drm_format_modifier") // 159
class VkImageDrmFormatModifierListCreateInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    u32                                             drmFormatModifierCount
    const u64*                                      pDrmFormatModifiers
}

@extension("VK_EXT_image_drm_format_modifier") // 159
class VkImageDrmFormatModifierExplicitCreateInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    u64                                             drmFormatModifier
    u32                                             drmFormatModifierPlaneCount
    const VkSubresourceLayout*                      pPlaneLayouts
}

@extension("VK_EXT_image_drm_format_modifier") // 159
class VkImageDrmFormatModifierPropertiesEXT {
    VkStructureType                                 sType
    void*                                           pNext
    u64                                             drmFormatModifier
}

@extension("VK_EXT_validation_cache") // 161
class VkValidationCacheCreateInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    VkValidationCacheCreateFlagsEXT                 flags
    platform.size_t                                 initialDataSize
    const void*                                     pInitialData
}

@extension("VK_EXT_validation_cache") // 161
class VkShaderModuleValidationCacheCreateInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    VkValidationCacheEXT                            validationCache
}

@extension("VK_EXT_descriptor_indexing") // 162
class VkDescriptorSetLayoutBindingFlagsCreateInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    u32                                             bindingCount
    const VkDescriptorBindingFlagsEXT*              pBindingFlags
}

@extension("VK_EXT_descriptor_indexing") // 162
class VkPhysicalDeviceDescriptorIndexingFeaturesEXT {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        shaderInputAttachmentArrayDynamicIndexing
    VkBool32                                        shaderUniformTexelBufferArrayDynamicIndexing
    VkBool32                                        shaderStorageTexelBufferArrayDynamicIndexing
    VkBool32                                        shaderUniformBufferArrayNonUniformIndexing
    VkBool32                                        shaderSampledImageArrayNonUniformIndexing
    VkBool32                                        shaderStorageBufferArrayNonUniformIndexing
    VkBool32                                        shaderStorageImageArrayNonUniformIndexing
    VkBool32                                        shaderInputAttachmentArrayNonUniformIndexing
    VkBool32                                        shaderUniformTexelBufferArrayNonUniformIndexing
    VkBool32                                        shaderStorageTexelBufferArrayNonUniformIndexing
    VkBool32                                        descriptorBindingUniformBufferUpdateAfterBind
    VkBool32                                        descriptorBindingSampledImageUpdateAfterBind
    VkBool32                                        descriptorBindingStorageImageUpdateAfterBind
    VkBool32                                        descriptorBindingStorageBufferUpdateAfterBind
    VkBool32                                        descriptorBindingUniformTexelBufferUpdateAfterBind
    VkBool32                                        descriptorBindingStorageTexelBufferUpdateAfterBind
    VkBool32                                        descriptorBindingUpdateUnusedWhilePending
    VkBool32                                        descriptorBindingPartiallyBound
    VkBool32                                        descriptorBindingVariableDescriptorCount
    VkBool32                                        runtimeDescriptorArray
}

@extension("VK_EXT_descriptor_indexing") // 162
class VkPhysicalDeviceDescriptorIndexingPropertiesEXT {
    VkStructureType                                 sType
    void*                                           pNext
    u32                                             maxUpdateAfterBindDescriptorsInAllPools
    VkBool32                                        shaderUniformBufferArrayNonUniformIndexingNative
    VkBool32                                        shaderSampledImageArrayNonUniformIndexingNative
    VkBool32                                        shaderStorageBufferArrayNonUniformIndexingNative
    VkBool32                                        shaderStorageImageArrayNonUniformIndexingNative
    VkBool32                                        shaderInputAttachmentArrayNonUniformIndexingNative
    VkBool32                                        robustBufferAccessUpdateAfterBind
    VkBool32                                        quadDivergentImplicitLod
    u32                                             maxPerStageDescriptorUpdateAfterBindSamplers
    u32                                             maxPerStageDescriptorUpdateAfterBindUniformBuffers
    u32                                             maxPerStageDescriptorUpdateAfterBindStorageBuffers
    u32                                             maxPerStageDescriptorUpdateAfterBindSampledImages
    u32                                             maxPerStageDescriptorUpdateAfterBindStorageImages
    u32                                             maxPerStageDescriptorUpdateAfterBindInputAttachments
    u32                                             maxPerStageUpdateAfterBindResources
    u32                                             maxDescriptorSetUpdateAfterBindSamplers
    u32                                             maxDescriptorSetUpdateAfterBindUniformBuffers
    u32                                             maxDescriptorSetUpdateAfterBindUniformBuffersDynamic
    u32                                             maxDescriptorSetUpdateAfterBindStorageBuffers
    u32                                             maxDescriptorSetUpdateAfterBindStorageBuffersDynamic
    u32                                             maxDescriptorSetUpdateAfterBindSampledImages
    u32                                             maxDescriptorSetUpdateAfterBindStorageImages
    u32                                             maxDescriptorSetUpdateAfterBindInputAttachments
}

@extension("VK_EXT_descriptor_indexing") // 162
class VkDescriptorSetVariableDescriptorCountAllocateInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    u32                                             descriptorSetCount
    const u32*                                      pDescriptorCounts
}

@extension("VK_EXT_descriptor_indexing") // 162
class VkDescriptorSetVariableDescriptorCountLayoutSupportEXT {
    VkStructureType                                 sType
    void*                                           pNext
    u32                                             maxVariableDescriptorCount
}

@extension("VK_NV_shading_rate_image") // 165
class VkShadingRatePaletteNV {
    u32                                             shadingRatePaletteEntryCount
    const VkShadingRatePaletteEntryNV*              pShadingRatePaletteEntries
}

@extension("VK_NV_shading_rate_image") // 165
class VkPipelineViewportShadingRateImageStateCreateInfoNV {
    VkStructureType                                 sType
    const void*                                     pNext
    VkBool32                                        shadingRateImageEnable
    u32                                             viewportCount
    const VkShadingRatePaletteNV*                   pShadingRatePalettes
}

@extension("VK_NV_shading_rate_image") // 165
class VkPhysicalDeviceShadingRateImageFeaturesNV {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        shadingRateImage
    VkBool32                                        shadingRateCoarseSampleOrder
}

@extension("VK_NV_shading_rate_image") // 165
class VkPhysicalDeviceShadingRateImagePropertiesNV {
    VkStructureType                                 sType
    void*                                           pNext
    VkExtent2D                                      shadingRateTexelSize
    u32                                             shadingRatePaletteSize
    u32                                             shadingRateMaxCoarseSamples
}

@extension("VK_NV_shading_rate_image") // 165
class VkCoarseSampleLocationNV {
    u32                                             pixelX
    u32                                             pixelY
    u32                                             sample
}

@extension("VK_NV_shading_rate_image") // 165
class VkCoarseSampleOrderCustomNV {
    VkShadingRatePaletteEntryNV                     shadingRate
    u32                                             sampleCount
    u32                                             sampleLocationCount
    const VkCoarseSampleLocationNV*                 pSampleLocations
}

@extension("VK_NV_shading_rate_image") // 165
class VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
    VkStructureType                                 sType
    const void*                                     pNext
    VkCoarseSampleOrderTypeNV                       sampleOrderType
    u32                                             customSampleOrderCount
    const VkCoarseSampleOrderCustomNV*              pCustomSampleOrders
}

@extension("VK_NVX_raytracing") // 166
class VkRaytracingPipelineCreateInfoNVX {
    VkStructureType                                 sType
    const void*                                     pNext
    VkPipelineCreateFlags                           flags
    u32                                             stageCount
    const VkPipelineShaderStageCreateInfo*          pStages
    const u32*                                      pGroupNumbers
    u32                                             maxRecursionDepth
    VkPipelineLayout                                layout
    VkPipeline                                      basePipelineHandle
    s32                                             basePipelineIndex
}

@extension("VK_NVX_raytracing") // 166
class VkGeometryTrianglesNVX {
    VkStructureType                                 sType
    const void*                                     pNext
    VkBuffer                                        vertexData
    VkDeviceSize                                    vertexOffset
    u32                                             vertexCount
    VkDeviceSize                                    vertexStride
    VkFormat                                        vertexFormat
    VkBuffer                                        indexData
    VkDeviceSize                                    indexOffset
    u32                                             indexCount
    VkIndexType                                     indexType
    VkBuffer                                        transformData
    VkDeviceSize                                    transformOffset
}

@extension("VK_NVX_raytracing") // 166
class VkGeometryAABBNVX {
    VkStructureType                                 sType
    const void*                                     pNext
    VkBuffer                                        aabbData
    u32                                             numAABBs
    u32                                             stride
    VkDeviceSize                                    offset
}

@extension("VK_NVX_raytracing") // 166
class VkGeometryDataNVX {
    VkGeometryTrianglesNVX                          triangles
    VkGeometryAABBNVX                               aabbs
}

@extension("VK_NVX_raytracing") // 166
class VkGeometryNVX {
    VkStructureType                                 sType
    const void*                                     pNext
    VkGeometryTypeNVX                               geometryType
    VkGeometryDataNVX                               geometry
    VkGeometryFlagsNVX                              flags
}

@extension("VK_NVX_raytracing") // 166
class VkAccelerationStructureCreateInfoNVX {
    VkStructureType                                 sType
    const void*                                     pNext
    VkAccelerationStructureTypeNVX                  type
    VkBuildAccelerationStructureFlagsNVX            flags
    VkDeviceSize                                    compactedSize
    u32                                             instanceCount
    u32                                             geometryCount
    const VkGeometryNVX*                            pGeometries
}

@extension("VK_NVX_raytracing") // 166
class VkBindAccelerationStructureMemoryInfoNVX {
    VkStructureType                                 sType
    const void*                                     pNext
    VkAccelerationStructureNVX                      accelerationStructure
    VkDeviceMemory                                  memory
    VkDeviceSize                                    memoryOffset
    u32                                             deviceIndexCount
    const u32*                                      pDeviceIndices
}

@extension("VK_NVX_raytracing") // 166
class VkDescriptorAccelerationStructureInfoNVX {
    VkStructureType                                 sType
    const void*                                     pNext
    u32                                             accelerationStructureCount
    const VkAccelerationStructureNVX*               pAccelerationStructures
}

@extension("VK_NVX_raytracing") // 166
class VkAccelerationStructureMemoryRequirementsInfoNVX {
    VkStructureType                                 sType
    const void*                                     pNext
    VkAccelerationStructureNVX                      accelerationStructure
}

@extension("VK_NVX_raytracing") // 166
class VkPhysicalDeviceRaytracingPropertiesNVX {
    VkStructureType                                 sType
    void*                                           pNext
    u32                                             shaderHeaderSize
    u32                                             maxRecursionDepth
    u32                                             maxGeometryCount
}

@extension("VK_NV_representative_fragment_test") // 167
class VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        representativeFragmentTest
}

@extension("VK_NV_representative_fragment_test") // 167
class VkPipelineRepresentativeFragmentTestStateCreateInfoNV {
    VkStructureType                                 sType
    const void*                                     pNext
    VkBool32                                        representativeFragmentTestEnable
}

@extension("VK_KHR_maintenance3") // 169
class VkPhysicalDeviceMaintenance3PropertiesKHR {
    VkStructureType                                 sType
    void*                                           pNext
    u32                                             maxPerSetDescriptors
    VkDeviceSize                                    maxMemoryAllocationSize
}

@extension("VK_KHR_maintenance3") // 169
class VkDescriptorSetLayoutSupportKHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        supported
}

@extension("VK_EXT_global_priority") // 175
class VkDeviceQueueGlobalPriorityCreateInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    VkQueueGlobalPriorityEXT                        globalPriority
}

@extension("VK_KHR_8bit_storage") // 178
class VkPhysicalDevice8BitStorageFeaturesKHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        storageBuffer8BitAccess
    VkBool32                                        uniformAndStorageBuffer8BitAccess
    VkBool32                                        storagePushConstant8
}

@extension("VK_EXT_external_memory_host") // 179
class VkImportMemoryHostPointerInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    VkExternalMemoryHandleTypeFlagBits              handleType
    void*                                           pHostPointer
}

@extension("VK_EXT_external_memory_host") // 179
class VkMemoryHostPointerPropertiesEXT {
    VkStructureType                                 sType
    void*                                           pNext
    u32                                             memoryTypeBits
}

@extension("VK_EXT_external_memory_host") // 179
class VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
    VkStructureType                                 sType
    void*                                           pNext
    VkDeviceSize                                    minImportedHostPointerAlignment
}

@extension("VK_KHR_shader_atomic_int64") // 181
class VkPhysicalDeviceShaderAtomicInt64FeaturesKHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        shaderBufferInt64Atomics
    VkBool32                                        shaderSharedInt64Atomics
}

@extension("VK_EXT_calibrated_timestamps") // 185
class VkCalibratedTimestampInfoEXT {
    VkStructureType                                 sType
    const void*                                     pNext
    VkTimeDomainEXT                                 timeDomain
}

@extension("VK_AMD_shader_core_properties") // 186
class VkPhysicalDeviceShaderCorePropertiesAMD {
    VkStructureType                                 sType
    void*                                           pNext
    u32                                             shaderEngineCount
    u32                                             shaderArraysPerEngineCount
    u32                                             computeUnitsPerShaderArray
    u32                                             simdPerComputeUnit
    u32                                             wavefrontsPerSimd
    u32                                             wavefrontSize
    u32                                             sgprsPerSimd
    u32                                             minSgprAllocation
    u32                                             maxSgprAllocation
    u32                                             sgprAllocationGranularity
    u32                                             vgprsPerSimd
    u32                                             minVgprAllocation
    u32                                             maxVgprAllocation
    u32                                             vgprAllocationGranularity
}

@extension("VK_EXT_vertex_attribute_divisor") // 191
class VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
    VkStructureType                                 sType
    void*                                           pNext
    u32                                             maxVertexAttribDivisor
}

@extension("VK_EXT_vertex_attribute_divisor") // 191
class VkVertexInputBindingDivisorDescriptionEXT {
    u32                                             binding
    u32                                             divisor
}

@extension("VK_EXT_vertex_attribute_divisor") // 191
class VkPipelineVertexInputDivisorStateCreateInfoEXT {
    VkStructureType                                     sType
    const void*                                         pNext
    u32                                                 vertexBindingDivisorCount
    const VkVertexInputBindingDivisorDescriptionEXT*    pVertexBindingDivisors
}

@extension("VK_EXT_vertex_attribute_divisor") // 191
class VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        vertexAttributeInstanceRateDivisor
    VkBool32                                        vertexAttributeInstanceRateZeroDivisor
}

@extension("VK_KHR_driver_properties") // 197
class VkConformanceVersionKHR {
    u8                                              major
    u8                                              minor
    u8                                              subminor
    u8                                              patch
}

@extension("VK_KHR_driver_properties") // 197
class VkPhysicalDeviceDriverPropertiesKHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkDriverIdKHR                                   driverID
    char[VK_MAX_DRIVER_NAME_SIZE_KHR]               driverName
    char[VK_MAX_DRIVER_INFO_SIZE_KHR]               driverInfo
    VkConformanceVersionKHR                         conformanceVersion
}

@extension("VK_NV_compute_shader_derivatives") // 202
class VkPhysicalDeviceComputeShaderDerivativesFeaturesNV {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        computeDerivativeGroupQuads
    VkBool32                                        computeDerivativeGroupLinear
}

@extension("VK_NV_mesh_shader") // 203
class VkPhysicalDeviceMeshShaderFeaturesNV {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        taskShader
    VkBool32                                        meshShader
}

@extension("VK_NV_mesh_shader") // 203
class VkPhysicalDeviceMeshShaderPropertiesNV {
    VkStructureType                                 sType
    void*                                           pNext
    u32                                             maxDrawMeshTasksCount
    u32                                             maxTaskWorkGroupInvocations
    u32[3]                                          maxTaskWorkGroupSize
    u32                                             maxTaskTotalMemorySize
    u32                                             maxTaskOutputCount
    u32                                             maxMeshWorkGroupInvocations
    u32[3]                                          maxMeshWorkGroupSize
    u32                                             maxMeshTotalMemorySize
    u32                                             maxMeshOutputVertices
    u32                                             maxMeshOutputPrimitives
    u32                                             maxMeshMultiviewViewCount
    u32                                             meshOutputPerVertexGranularity
    u32                                             meshOutputPerPrimitiveGranularity
}

@extension("VK_NV_mesh_shader") // 203
class VkDrawMeshTasksIndirectCommandNV {
    u32                                             taskCount
    u32                                             firstTask
}

@extension("VK_NV_fragment_shader_barycentric") // 204
class VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        fragmentShaderBarycentric
}

@extension("VK_NV_shader_image_footprint") // 205
class VkPhysicalDeviceShaderImageFootprintFeaturesNV {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        imageFootprint
}

@extension("VK_NV_scissor_exclusive") // 206
class VkPipelineViewportExclusiveScissorStateCreateInfoNV {
    VkStructureType                                 sType
    const void*                                     pNext
    u32                                             exclusiveScissorCount
    const VkRect2D*                                 pExclusiveScissors
}

@extension("VK_NV_scissor_exclusive") // 206
class VkPhysicalDeviceExclusiveScissorFeaturesNV {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        exclusiveScissor
}

@extension("VK_NV_device_diagnostic_checkpoints") // 207
class VkQueueFamilyCheckpointPropertiesNV {
    VkStructureType                                 sType
    void*                                           pNext
    VkPipelineStageFlags                            checkpointExecutionStageMask
}

@extension("VK_NV_device_diagnostic_checkpoints") // 207
class VkCheckpointDataNV {
    VkStructureType                                 sType
    void*                                           pNext
    VkPipelineStageFlagBits                         stage
    void*                                           pCheckpointMarker
}

@extension("VK_KHR_vulkan_memory_model") // 212
class VkPhysicalDeviceVulkanMemoryModelFeaturesKHR {
    VkStructureType                                 sType
    void*                                           pNext
    VkBool32                                        vulkanMemoryModel
    VkBool32                                        vulkanMemoryModelDeviceScope
}

@extension("VK_EXT_pci_bus_info") // 213
class VkPhysicalDevicePCIBusInfoPropertiesEXT {
    VkStructureType                                 sType
    void*                                           pNext
    u16                                             pciDomain
    u8                                              pciBus
    u8                                              pciDevice
    u8                                              pciFunction
}

@extension("VK_FUCHSIA_imagepipe_surface") // 215
class VkImagePipeSurfaceCreateInfoFUCHSIA {
    VkStructureType                                 sType
    const void*                                     pNext
    VkImagePipeSurfaceCreateFlagsFUCHSIA            flags
    platform.zx_handle_t                            imagePipeHandle
}


////////////////
//  Commands  //
////////////////

// Function pointers. TODO: add support for function pointers.

@external type void* PFN_vkVoidFunction
@pfn cmd void vkVoidFunction() {
}

@external type void* PFN_vkAllocationFunction
@pfn cmd void* vkAllocationFunction(
        void*                                       pUserData,
        platform.size_t                             size,
        platform.size_t                             alignment,
        VkSystemAllocationScope                     allocationScope) {
    return ?
}

@external type void* PFN_vkReallocationFunction
@pfn cmd void* vkReallocationFunction(
        void*                                       pUserData,
        void*                                       pOriginal,
        platform.size_t                             size,
        platform.size_t                             alignment,
        VkSystemAllocationScope                     allocationScope) {
    return ?
}

@external type void* PFN_vkFreeFunction
@pfn cmd void vkFreeFunction(
        void*                                       pUserData,
        void*                                       pMemory) {
}

@external type void* PFN_vkInternalAllocationNotification
@pfn cmd void vkInternalAllocationNotification(
        void*                                       pUserData,
        platform.size_t                             size,
        VkInternalAllocationType                    allocationType,
        VkSystemAllocationScope                     allocationScope) {
}

@external type void* PFN_vkInternalFreeNotification
@pfn cmd void vkInternalFreeNotification(
        void*                                       pUserData,
        platform.size_t                             size,
        VkInternalAllocationType                    allocationType,
        VkSystemAllocationScope                     allocationScope) {
}

// Global functions

@threadSafety("system")
cmd VkResult vkCreateInstance(
        const VkInstanceCreateInfo*                 pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkInstance*                                 pInstance) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO)

    instance := ?
    pInstance[0] = instance
    State.Instances[instance] = new!InstanceObject()

    layers := pCreateInfo.ppEnabledLayerNames[0:pCreateInfo.enabledLayerCount]
    extensions := pCreateInfo.ppEnabledExtensionNames[0:pCreateInfo.enabledExtensionCount]

    return ?
}

@threadSafety("system")
cmd void vkDestroyInstance(
        VkInstance                                  instance,
        const VkAllocationCallbacks*                pAllocator) {
    instanceObject := GetInstance(instance)

    State.Instances[instance] = null
}

@threadSafety("system")
cmd VkResult vkEnumeratePhysicalDevices(
        VkInstance                                  instance,
        u32*                                        pPhysicalDeviceCount,
        VkPhysicalDevice*                           pPhysicalDevices) {
    instanceObject := GetInstance(instance)

    physicalDeviceCount := as!u32(?)
    pPhysicalDeviceCount[0] = physicalDeviceCount
    physicalDevices := pPhysicalDevices[0:physicalDeviceCount]

    for i in (0 .. physicalDeviceCount) {
        physicalDevice := ?
        physicalDevices[i] = physicalDevice
        if !(physicalDevice in State.PhysicalDevices) {
            State.PhysicalDevices[physicalDevice] = new!PhysicalDeviceObject(instance: instance)
        }
    }

    return ?
}

cmd PFN_vkVoidFunction vkGetDeviceProcAddr(
        VkDevice                                    device,
        const char*                                 pName) {
    if device != NULL_HANDLE {
        device := GetDevice(device)
    }

    return ?
}

cmd PFN_vkVoidFunction vkGetInstanceProcAddr(
        VkInstance                                  instance,
        const char*                                 pName) {
    if instance != NULL_HANDLE {
        instanceObject := GetInstance(instance)
    }

    return ?
}

cmd void vkGetPhysicalDeviceProperties(
        VkPhysicalDevice                            physicalDevice,
        VkPhysicalDeviceProperties*                 pProperties) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)

    properties := ?
    pProperties[0] = properties
}

cmd void vkGetPhysicalDeviceQueueFamilyProperties(
        VkPhysicalDevice                            physicalDevice,
        u32*                                        pQueueFamilyPropertyCount,
        VkQueueFamilyProperties*                    pQueueFamilyProperties) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
    // TODO: Figure out how to express fetch-count-or-properties
    // This version fails 'apic validate' with 'fence not allowed in
    // *semantic.Branch'. Other attempts have failed with the same or other
    // errors.
    // if pQueueFamilyProperties != null {
    //     queuesProperties := pQueueFamilyProperties[0:pCount[0]]
    //     for i in (0 .. pCount[0]) {
    //         queueProperties := as!VkQueueFamilyProperties(?)
    //         queuesProperties[i] = queueProperties
    //    }
    // } else {
    //     count := ?
    //     pCount[0] = count
    // }
}

cmd void vkGetPhysicalDeviceMemoryProperties(
        VkPhysicalDevice                            physicalDevice,
        VkPhysicalDeviceMemoryProperties*           pMemoryProperties) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)

    memoryProperties := ?
    pMemoryProperties[0] = memoryProperties
}

cmd void vkGetPhysicalDeviceFeatures(
        VkPhysicalDevice                            physicalDevice,
        VkPhysicalDeviceFeatures*                   pFeatures) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)

    features := ?
    pFeatures[0] = features
}

cmd void vkGetPhysicalDeviceFormatProperties(
        VkPhysicalDevice                            physicalDevice,
        VkFormat                                    format,
        VkFormatProperties*                         pFormatProperties) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)

    formatProperties := ?
    pFormatProperties[0] = formatProperties
}

cmd VkResult vkGetPhysicalDeviceImageFormatProperties(
        VkPhysicalDevice                            physicalDevice,
        VkFormat                                    format,
        VkImageType                                 type,
        VkImageTiling                               tiling,
        VkImageUsageFlags                           usage,
        VkImageCreateFlags                          flags,
        VkImageFormatProperties*                    pImageFormatProperties) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)

    imageFormatProperties := ?
    pImageFormatProperties[0] = imageFormatProperties

    return ?
}


// Device functions

@threadSafety("system")
cmd VkResult vkCreateDevice(
        VkPhysicalDevice                            physicalDevice,
        const VkDeviceCreateInfo*                   pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkDevice*                                   pDevice) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO)
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)

    device := ?
    pDevice[0] = device
    State.Devices[device] = new!DeviceObject(physicalDevice: physicalDevice)

    return ?
}

@threadSafety("system")
cmd void vkDestroyDevice(
        VkDevice                                    device,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)

    State.Devices[device] = null
}


// Extension discovery functions

cmd VkResult vkEnumerateInstanceLayerProperties(
        u32*                                        pPropertyCount,
        VkLayerProperties*                          pProperties) {
    count := as!u32(?)
    pPropertyCount[0] = count

    properties := pProperties[0:count]
    for i in (0 .. count) {
        property := ?
        properties[i] = property
    }

    return ?
}

cmd VkResult vkEnumerateInstanceExtensionProperties(
        const char*                                 pLayerName,
        u32*                                        pPropertyCount,
        VkExtensionProperties*                      pProperties) {
    count := as!u32(?)
    pPropertyCount[0] = count

    properties := pProperties[0:count]
    for i in (0 .. count) {
        property := ?
        properties[i] = property
    }

    return ?
}

cmd VkResult vkEnumerateDeviceLayerProperties(
        VkPhysicalDevice                            physicalDevice,
        u32*                                        pPropertyCount,
        VkLayerProperties*                          pProperties) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
    count := as!u32(?)
    pPropertyCount[0] = count

    properties := pProperties[0:count]
    for i in (0 .. count) {
        property := ?
        properties[i] = property
    }

    return ?
}

cmd VkResult vkEnumerateDeviceExtensionProperties(
        VkPhysicalDevice                            physicalDevice,
        const char*                                 pLayerName,
        u32*                                        pPropertyCount,
        VkExtensionProperties*                      pProperties) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)

    count := as!u32(?)
    pPropertyCount[0] = count

    properties := pProperties[0:count]
    for i in (0 .. count) {
        property := ?
        properties[i] = property
    }

    return ?
}


// Queue functions

@threadSafety("system")
cmd void vkGetDeviceQueue(
        VkDevice                                    device,
        u32                                         queueFamilyIndex,
        u32                                         queueIndex,
        VkQueue*                                    pQueue) {
    deviceObject := GetDevice(device)

    queue := ?
    pQueue[0] = queue

    if !(queue in State.Queues) {
        State.Queues[queue] = new!QueueObject(device: device)
    }
}

@threadSafety("app")
cmd VkResult vkQueueSubmit(
        VkQueue                                     queue,
        u32                                         submitCount,
        const VkSubmitInfo*                         pSubmits,
        VkFence                                     fence) {
    queueObject := GetQueue(queue)

    if fence != NULL_HANDLE {
        fenceObject := GetFence(fence)
        assert(fenceObject.device == queueObject.device)
    }

    // commandBuffers := pcommandBuffers[0:commandBufferCount]
    // for i in (0 .. commandBufferCount) {
    //    commandBuffer := commandBuffers[i]
    //    commandBufferObject := GetCommandBuffer(commandBuffer)
    //    assert(commandBufferObject.device == queueObject.device)
    //
    //    validate("QueueCheck", commandBufferObject.queueFlags in queueObject.flags,
    //        "vkQueueSubmit: enqueued commandBuffer requires missing queue capabilities.")
    // }

    return ?
}

@threadSafety("system")
cmd VkResult vkQueueWaitIdle(
        VkQueue                                     queue) {
    queueObject := GetQueue(queue)

    return ?
}

@threadSafety("system")
cmd VkResult vkDeviceWaitIdle(
        VkDevice                                    device) {
    deviceObject := GetDevice(device)

    return ?
}


// Memory functions

@threadSafety("system")
cmd VkResult vkAllocateMemory(
        VkDevice                                    device,
        const VkMemoryAllocateInfo*                 pAllocateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkDeviceMemory*                             pMemory) {
    assert(pAllocateInfo.sType == VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO)
    deviceObject := GetDevice(device)

    memory := ?
    pMemory[0] = memory
    State.DeviceMemories[memory] = new!DeviceMemoryObject(
        device: device,
        allocationSize: pAllocateInfo[0].allocationSize)

    return ?
}

@threadSafety("system")
cmd void vkFreeMemory(
        VkDevice                                    device,
        VkDeviceMemory                              memory,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    memoryObject := GetDeviceMemory(memory)
    assert(memoryObject.device == device)

    // Check that no objects are still bound before freeing.
    validate("MemoryCheck", len(memoryObject.boundObjects) == 0,
        "vkFreeMemory: objects still bound")
    validate("MemoryCheck", len(memoryObject.boundCommandBuffers) == 0,
        "vkFreeMemory: commandBuffers still bound")
    State.DeviceMemories[memory] = null
}

@threadSafety("app")
cmd VkResult vkMapMemory(
        VkDevice                                    device,
        VkDeviceMemory                              memory,
        VkDeviceSize                                offset,
        VkDeviceSize                                size,
        VkMemoryMapFlags                            flags,
        void**                                      ppData) {
    deviceObject := GetDevice(device)
    memoryObject := GetDeviceMemory(memory)
    assert(memoryObject.device == device)

    assert(flags == as!VkMemoryMapFlags(0))
    assert((offset + size) <= memoryObject.allocationSize)

    return ?
}

@threadSafety("app")
cmd void vkUnmapMemory(
        VkDevice                                    device,
        VkDeviceMemory                              memory) {
    deviceObject := GetDevice(device)
    memoryObject := GetDeviceMemory(memory)
    assert(memoryObject.device == device)
}

cmd VkResult vkFlushMappedMemoryRanges(
        VkDevice                                    device,
        u32                                         memoryRangeCount
        const VkMappedMemoryRange*                  pMemoryRanges) {
    deviceObject := GetDevice(device)

    memoryRanges := pMemoryRanges[0:memoryRangeCount]
    for i in (0 .. memoryRangeCount) {
        memoryRange := memoryRanges[i]
        memoryObject := GetDeviceMemory(memoryRange.memory)
        assert(memoryObject.device == device)
        assert((memoryRange.offset + memoryRange.size) <= memoryObject.allocationSize)
    }

    return ?
}

cmd VkResult vkInvalidateMappedMemoryRanges(
        VkDevice                                    device,
        u32                                         memoryRangeCount,
        const VkMappedMemoryRange*                  pMemoryRanges) {
    deviceObject := GetDevice(device)

    memoryRanges := pMemoryRanges[0:memoryRangeCount]
    for i in (0 .. memoryRangeCount) {
        memoryRange := memoryRanges[i]
        memoryObject := GetDeviceMemory(memoryRange.memory)
        assert(memoryObject.device == device)
        assert((memoryRange.offset + memoryRange.size) <= memoryObject.allocationSize)
    }

    return ?
}


// Memory management API functions

cmd void vkGetDeviceMemoryCommitment(
        VkDevice                                    device,
        VkDeviceMemory                              memory,
        VkDeviceSize*                               pCommittedMemoryInBytes) {
    deviceObject := GetDevice(device)

    if memory != NULL_HANDLE {
        memoryObject := GetDeviceMemory(memory)
        assert(memoryObject.device == device)
    }

    committedMemoryInBytes := ?
    pCommittedMemoryInBytes[0] = committedMemoryInBytes
}

cmd void vkGetBufferMemoryRequirements(
        VkDevice                                    device,
        VkBuffer                                    buffer,
        VkMemoryRequirements*                       pMemoryRequirements) {
    deviceObject := GetDevice(device)
    bufferObject := GetBuffer(buffer)
    assert(bufferObject.device == device)
}

cmd VkResult vkBindBufferMemory(
        VkDevice                                    device,
        VkBuffer                                    buffer,
        VkDeviceMemory                              memory,
        VkDeviceSize                                memoryOffset) {
    deviceObject := GetDevice(device)
    bufferObject := GetBuffer(buffer)
    assert(bufferObject.device == device)

    // Unbind buffer from previous memory object, if not VK_NULL_HANDLE.
    if bufferObject.memory != NULL_HANDLE {
        memoryObject := GetDeviceMemory(bufferObject.memory)
        memoryObject.boundObjects[as!u64(buffer)] = null
    }

    // Bind buffer to given memory object, if not VK_NULL_HANDLE.
    if memory != NULL_HANDLE {
        memoryObject := GetDeviceMemory(memory)
        assert(memoryObject.device == device)
        memoryObject.boundObjects[as!u64(buffer)] = memoryOffset
    }
    bufferObject.memory = memory
    bufferObject.memoryOffset = memoryOffset

    return ?
}

cmd void vkGetImageMemoryRequirements(
        VkDevice                                    device,
        VkImage                                     image,
        VkMemoryRequirements*                       pMemoryRequirements) {
    deviceObject := GetDevice(device)
    imageObject := GetImage(image)
    assert(imageObject.device == device)
}

cmd VkResult vkBindImageMemory(
        VkDevice                                    device,
        VkImage                                     image,
        VkDeviceMemory                              memory,
        VkDeviceSize                                memoryOffset) {
    deviceObject := GetDevice(device)
    imageObject := GetImage(image)
    assert(imageObject.device == device)

    // Unbind image from previous memory object, if not VK_NULL_HANDLE.
    if imageObject.memory != NULL_HANDLE {
        memoryObject := GetDeviceMemory(imageObject.memory)
        memoryObject.boundObjects[as!u64(image)] = null
    }

    // Bind image to given memory object, if not VK_NULL_HANDLE.
    if memory != NULL_HANDLE {
        memoryObject := GetDeviceMemory(memory)
        assert(memoryObject.device == device)
        memoryObject.boundObjects[as!u64(image)] = memoryOffset
    }
    imageObject.memory = memory
    imageObject.memoryOffset = memoryOffset

    return ?
}

cmd void vkGetImageSparseMemoryRequirements(
        VkDevice                                    device,
        VkImage                                     image,
        u32*                                        pSparseMemoryRequirementCount,
        VkSparseImageMemoryRequirements*            pSparseMemoryRequirements) {
    deviceObject := GetDevice(device)
    imageObject := GetImage(image)
    assert(imageObject.device == device)
}

cmd void vkGetPhysicalDeviceSparseImageFormatProperties(
        VkPhysicalDevice                            physicalDevice,
        VkFormat                                    format,
        VkImageType                                 type,
        VkSampleCountFlagBits                       samples,
        VkImageUsageFlags                           usage,
        VkImageTiling                               tiling,
        u32*                                        pPropertyCount,
        VkSparseImageFormatProperties*              pProperties) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
}

cmd VkResult vkQueueBindSparse(
        VkQueue                                     queue,
        u32                                         bindInfoCount,
        const VkBindSparseInfo*                     pBindInfo,
        VkFence                                     fence) {
    queueObject := GetQueue(queue)

    return ?
}


// Fence functions

@threadSafety("system")
cmd VkResult vkCreateFence(
        VkDevice                                    device,
        const VkFenceCreateInfo*                    pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkFence*                                    pFence) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_FENCE_CREATE_INFO)
    deviceObject := GetDevice(device)

    fence := ?
    pFence[0] = fence
    State.Fences[fence] = new!FenceObject(
        device: device, signaled: (pCreateInfo.flags == as!VkFenceCreateFlags(VK_FENCE_CREATE_SIGNALED_BIT)))

    return ?
}

@threadSafety("system")
cmd void vkDestroyFence(
        VkDevice                                    device,
        VkFence                                     fence,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    fenceObject := GetFence(fence)
    assert(fenceObject.device == device)

    State.Fences[fence] = null
}

@threadSafety("system")
cmd VkResult vkResetFences(
        VkDevice                                    device,
        u32                                         fenceCount,
        const VkFence*                              pFences) {
    deviceObject := GetDevice(device)

    fences := pFences[0:fenceCount]
    for i in (0 .. fenceCount) {
        fence := fences[i]
        fenceObject := GetFence(fence)
        assert(fenceObject.device == device)
        fenceObject.signaled = false
    }

    return ?
}

@threadSafety("system")
cmd VkResult vkGetFenceStatus(
        VkDevice                                    device,
        VkFence                                     fence) {
    deviceObject := GetDevice(device)
    fenceObject := GetFence(fence)
    assert(fenceObject.device == device)

    return ?
}

@threadSafety("system")
cmd VkResult vkWaitForFences(
        VkDevice                                    device,
        u32                                         fenceCount,
        const VkFence*                              pFences,
        VkBool32                                    waitAll,
        u64                                         timeout) {  /// timeout in nanoseconds
    deviceObject := GetDevice(device)

    fences := pFences[0:fenceCount]
    for i in (0 .. fenceCount) {
        fence := fences[i]
        fenceObject := GetFence(fence)
        assert(fenceObject.device == device)
    }

    return ?
}


// Queue semaphore functions

@threadSafety("system")
cmd VkResult vkCreateSemaphore(
        VkDevice                                    device,
        const VkSemaphoreCreateInfo*                pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkSemaphore*                                pSemaphore) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO)
    deviceObject := GetDevice(device)

    semaphore := ?
    pSemaphore[0] = semaphore
    State.Semaphores[semaphore] = new!SemaphoreObject(device: device)

    return ?
}

@threadSafety("system")
cmd void vkDestroySemaphore(
        VkDevice                                    device,
        VkSemaphore                                 semaphore,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    semaphoreObject := GetSemaphore(semaphore)
    assert(semaphoreObject.device == device)

    State.Semaphores[semaphore] = null
}


// Event functions

@threadSafety("system")
cmd VkResult vkCreateEvent(
        VkDevice                                    device,
        const VkEventCreateInfo*                    pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkEvent*                                    pEvent) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_EVENT_CREATE_INFO)
    deviceObject := GetDevice(device)

    event := ?
    pEvent[0] = event
    State.Events[event] = new!EventObject(device: device)

    return ?
}

@threadSafety("system")
cmd void vkDestroyEvent(
        VkDevice                                    device,
        VkEvent                                     event,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    eventObject := GetEvent(event)
    assert(eventObject.device == device)

    State.Events[event] = null
}

@threadSafety("system")
cmd VkResult vkGetEventStatus(
        VkDevice                                    device,
        VkEvent                                     event) {
    deviceObject := GetDevice(device)
    eventObject := GetEvent(event)
    assert(eventObject.device == device)

    return ?
}

@threadSafety("system")
cmd VkResult vkSetEvent(
        VkDevice                                    device,
        VkEvent                                     event) {
    deviceObject := GetDevice(device)
    eventObject := GetEvent(event)
    assert(eventObject.device == device)

    return ?
}

@threadSafety("system")
cmd VkResult vkResetEvent(
        VkDevice                                    device,
        VkEvent                                     event) {
    deviceObject := GetDevice(device)
    eventObject := GetEvent(event)
    assert(eventObject.device == device)

    return ?
}


// Query functions

@threadSafety("system")
cmd VkResult vkCreateQueryPool(
        VkDevice                                    device,
        const VkQueryPoolCreateInfo*                pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkQueryPool*                                pQueryPool) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO)
    deviceObject := GetDevice(device)

    queryPool := ?
    pQueryPool[0] = queryPool
    State.QueryPools[queryPool] = new!QueryPoolObject(device: device)

    return ?
}

@threadSafety("system")
cmd void vkDestroyQueryPool(
        VkDevice                                    device,
        VkQueryPool                                 queryPool,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    queryPoolObject := GetQueryPool(queryPool)
    assert(queryPoolObject.device == device)

    State.QueryPools[queryPool] = null
}

@threadSafety("system")
cmd VkResult vkGetQueryPoolResults(
        VkDevice                                    device,
        VkQueryPool                                 queryPool,
        u32                                         firstQuery,
        u32                                         queryCount,
        platform.size_t                             dataSize,
        void*                                       pData,
        VkDeviceSize                                stride,
        VkQueryResultFlags                          flags) {
    deviceObject := GetDevice(device)
    queryPoolObject := GetQueryPool(queryPool)
    assert(queryPoolObject.device == device)

    data := pData[0:dataSize]

    return ?
}

// Buffer functions

@threadSafety("system")
cmd VkResult vkCreateBuffer(
        VkDevice                                    device,
        const VkBufferCreateInfo*                   pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkBuffer*                                   pBuffer) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO)
    deviceObject := GetDevice(device)

    buffer := ?
    pBuffer[0] = buffer
    State.Buffers[buffer] = new!BufferObject(device: device)

    return ?
}

@threadSafety("system")
cmd void vkDestroyBuffer(
        VkDevice                                    device,
        VkBuffer                                    buffer,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    bufferObject := GetBuffer(buffer)
    assert(bufferObject.device == device)

    assert(bufferObject.memory == 0)
    State.Buffers[buffer] = null
}


// Buffer view functions

@threadSafety("system")
cmd VkResult vkCreateBufferView(
        VkDevice                                    device,
        const VkBufferViewCreateInfo*               pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkBufferView*                               pView) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO)
    deviceObject := GetDevice(device)

    bufferObject := GetBuffer(pCreateInfo.buffer)
    assert(bufferObject.device == device)

    view := ?
    pView[0] = view
    State.BufferViews[view] = new!BufferViewObject(device: device, buffer: pCreateInfo.buffer)

    return ?
}

@threadSafety("system")
cmd void vkDestroyBufferView(
        VkDevice                                    device,
        VkBufferView                                bufferView,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    bufferViewObject := GetBufferView(bufferView)
    assert(bufferViewObject.device == device)

    State.BufferViews[bufferView] = null
}


// Image functions

@threadSafety("system")
cmd VkResult vkCreateImage(
        VkDevice                                    device,
        const VkImageCreateInfo*                    pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkImage*                                    pImage) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO)
    deviceObject := GetDevice(device)

    image := ?
    pImage[0] = image
    State.Images[image] = new!ImageObject(device: device)

    return ?
}

@threadSafety("system")
cmd void vkDestroyImage(
        VkDevice                                    device,
        VkImage                                     image,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    imageObject := GetImage(image)
    assert(imageObject.device == device)

    assert(imageObject.memory == 0)
    State.Images[image] = null
}

cmd void vkGetImageSubresourceLayout(
        VkDevice                                    device,
        VkImage                                     image,
        const VkImageSubresource*                   pSubresource,
        VkSubresourceLayout*                        pLayout) {
    deviceObject := GetDevice(device)
    imageObject := GetImage(image)
    assert(imageObject.device == device)
}


// Image view functions

@threadSafety("system")
cmd VkResult vkCreateImageView(
        VkDevice                                    device,
        const VkImageViewCreateInfo*                pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkImageView*                                pView) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO)
    deviceObject := GetDevice(device)

    imageObject := GetImage(pCreateInfo.image)
    assert(imageObject.device == device)

    view := ?
    pView[0] = view
    State.ImageViews[view] = new!ImageViewObject(device: device, image: pCreateInfo.image)

    return ?
}

@threadSafety("system")
cmd void vkDestroyImageView(
        VkDevice                                    device,
        VkImageView                                 imageView,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    imageViewObject := GetImageView(imageView)
    assert(imageViewObject.device == device)

    State.ImageViews[imageView] = null
}


// Shader functions

cmd VkResult vkCreateShaderModule(
        VkDevice                                    device,
        const VkShaderModuleCreateInfo*             pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkShaderModule*                             pShaderModule) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO)
    deviceObject := GetDevice(device)

    shaderModule := ?
    pShaderModule[0] = shaderModule
    State.ShaderModules[shaderModule] = new!ShaderModuleObject(device: device)

    return ?
}

cmd void vkDestroyShaderModule(
        VkDevice                                    device,
        VkShaderModule                              shaderModule,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    shaderModuleObject := GetShaderModule(shaderModule)
    assert(shaderModuleObject.device == device)

    State.ShaderModules[shaderModule] = null
}


// Pipeline functions

cmd VkResult vkCreatePipelineCache(
        VkDevice                                    device,
        const VkPipelineCacheCreateInfo*            pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkPipelineCache*                            pPipelineCache) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO)
    deviceObject := GetDevice(device)

    pipelineCache := ?
    pPipelineCache[0] = pipelineCache
    State.PipelineCaches[pipelineCache] = new!PipelineCacheObject(device: device)

    return ?
}

cmd void vkDestroyPipelineCache(
        VkDevice                                    device,
        VkPipelineCache                             pipelineCache,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    pipelineCacheObject := GetPipelineCache(pipelineCache)
    assert(pipelineCacheObject.device == device)

    State.PipelineCaches[pipelineCache] = null
}

cmd VkResult vkGetPipelineCacheData(
        VkDevice                                    device,
        VkPipelineCache                             pipelineCache,
        platform.size_t*                            pDataSize,
        void*                                       pData) {
    deviceObject := GetDevice(device)
    pipelineCacheObject := GetPipelineCache(pipelineCache)
    assert(pipelineCacheObject.device == device)

    return ?
}

cmd VkResult vkMergePipelineCaches(
        VkDevice                                    device,
        VkPipelineCache                             dstCache,
        u32                                         srcCacheCount,
        const VkPipelineCache*                      pSrcCaches) {
    deviceObject := GetDevice(device)
    dstCacheObject := GetPipelineCache(dstCache)
    assert(dstCacheObject.device == device)

    srcCaches := pSrcCaches[0:srcCacheCount]
    for i in (0 .. srcCacheCount) {
        srcCache := srcCaches[i]
        srcCacheObject := GetPipelineCache(srcCache)
        assert(srcCacheObject.device == device)
    }

    return ?
}

cmd VkResult vkCreateGraphicsPipelines(
        VkDevice                                    device,
        VkPipelineCache                             pipelineCache,
        u32                                         createInfoCount,
        const VkGraphicsPipelineCreateInfo*         pCreateInfos,
        const VkAllocationCallbacks*                pAllocator,
        VkPipeline*                                 pPipelines) {
    deviceObject := GetDevice(device)
    if pipelineCache != NULL_HANDLE {
        pipelineCacheObject := GetPipelineCache(pipelineCache)
        assert(pipelineCacheObject.device == device)
    }

    createInfos := pCreateInfos[0:createInfoCount]
    pipelines := pPipelines[0:createInfoCount]
    for i in (0 .. createInfoCount) {
        pipeline := ?
        pipelines[i] = pipeline
        State.Pipelines[pipeline] = new!PipelineObject(device: device)
    }

    return ?
}

cmd VkResult vkCreateComputePipelines(
        VkDevice                                    device,
        VkPipelineCache                             pipelineCache,
        u32                                         createInfoCount,
        const VkComputePipelineCreateInfo*          pCreateInfos,
        const VkAllocationCallbacks*                pAllocator,
        VkPipeline*                                 pPipelines) {
    deviceObject := GetDevice(device)
    if pipelineCache != NULL_HANDLE {
        pipelineCacheObject := GetPipelineCache(pipelineCache)
        assert(pipelineCacheObject.device == device)
    }

    createInfos := pCreateInfos[0:createInfoCount]
    pipelines := pPipelines[0:createInfoCount]
    for i in (0 .. createInfoCount) {
        pipeline := ?
        pipelines[i] = pipeline
        State.Pipelines[pipeline] = new!PipelineObject(device: device)
    }

    return ?
}

@threadSafety("system")
cmd void vkDestroyPipeline(
        VkDevice                                    device,
        VkPipeline                                  pipeline,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    pipelineObjects := GetPipeline(pipeline)
    assert(pipelineObjects.device == device)

    State.Pipelines[pipeline] = null
}


// Pipeline layout functions

@threadSafety("system")
cmd VkResult vkCreatePipelineLayout(
        VkDevice                                    device,
        const VkPipelineLayoutCreateInfo*           pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkPipelineLayout*                           pPipelineLayout) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO)
    deviceObject := GetDevice(device)

    pipelineLayout := ?
    pPipelineLayout[0] = pipelineLayout
    State.PipelineLayouts[pipelineLayout] = new!PipelineLayoutObject(device: device)

    return ?
}

@threadSafety("system")
cmd void vkDestroyPipelineLayout(
        VkDevice                                    device,
        VkPipelineLayout                            pipelineLayout,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    pipelineLayoutObjects := GetPipelineLayout(pipelineLayout)
    assert(pipelineLayoutObjects.device == device)

    State.PipelineLayouts[pipelineLayout] = null
}


// Sampler functions

@threadSafety("system")
cmd VkResult vkCreateSampler(
        VkDevice                                    device,
        const VkSamplerCreateInfo*                  pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkSampler*                                  pSampler) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO)
    deviceObject := GetDevice(device)

    sampler := ?
    pSampler[0] = sampler
    State.Samplers[sampler] = new!SamplerObject(device: device)

    return ?
}

@threadSafety("system")
cmd void vkDestroySampler(
        VkDevice                                    device,
        VkSampler                                   sampler,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    samplerObject := GetSampler(sampler)
    assert(samplerObject.device == device)

    State.Samplers[sampler] = null
}


// Descriptor set functions

@threadSafety("system")
cmd VkResult vkCreateDescriptorSetLayout(
        VkDevice                                    device,
        const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkDescriptorSetLayout*                      pSetLayout) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO)
    deviceObject := GetDevice(device)

    setLayout := ?
    pSetLayout[0] = setLayout
    State.DescriptorSetLayouts[setLayout] = new!DescriptorSetLayoutObject(device: device)

    return ?
}

@threadSafety("system")
cmd void vkDestroyDescriptorSetLayout(
        VkDevice                                    device,
        VkDescriptorSetLayout                       descriptorSetLayout,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    descriptorSetLayoutObject := GetDescriptorSetLayout(descriptorSetLayout)
    assert(descriptorSetLayoutObject.device == device)

    State.DescriptorSetLayouts[descriptorSetLayout] = null
}

@threadSafety("system")
cmd VkResult vkCreateDescriptorPool(
        VkDevice                                    device,
        const VkDescriptorPoolCreateInfo*           pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkDescriptorPool*                           pDescriptorPool) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO)
    deviceObject := GetDevice(device)

    descriptorPool := ?
    pDescriptorPool[0] = descriptorPool
    State.DescriptorPools[descriptorPool] = new!DescriptorPoolObject(device: device)

    return ?
}

@threadSafety("system")
cmd void vkDestroyDescriptorPool(
        VkDevice                                    device,
        VkDescriptorPool                            descriptorPool,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    descriptorPoolObject := GetDescriptorPool(descriptorPool)
    assert(descriptorPoolObject.device == device)

    State.DescriptorPools[descriptorPool] = null
}

@threadSafety("app")
cmd VkResult vkResetDescriptorPool(
        VkDevice                                    device,
        VkDescriptorPool                            descriptorPool,
        VkDescriptorPoolResetFlags                  flags) {
    deviceObject := GetDevice(device)
    descriptorPoolObject := GetDescriptorPool(descriptorPool)
    assert(descriptorPoolObject.device == device)

    return ?
}

@threadSafety("app")
cmd VkResult vkAllocateDescriptorSets(
        VkDevice                                    device,
        const VkDescriptorSetAllocateInfo*          pAllocateInfo,
        VkDescriptorSet*                            pDescriptorSets) {
    deviceObject := GetDevice(device)
    allocInfo := pAllocateInfo[0]
    descriptorPoolObject := GetDescriptorPool(allocInfo.descriptorPool)

    setLayouts := allocInfo.pSetLayouts[0:allocInfo.setCount]
    for i in (0 .. allocInfo.setCount) {
        setLayout := setLayouts[i]
        setLayoutObject := GetDescriptorSetLayout(setLayout)
        assert(setLayoutObject.device == device)
    }

    descriptorSets := pDescriptorSets[0:allocInfo.setCount]
    for i in (0 .. allocInfo.setCount) {
        descriptorSet := ?
        descriptorSets[i] = descriptorSet
        State.DescriptorSets[descriptorSet] = new!DescriptorSetObject(device: device)
    }

    return ?
}

cmd VkResult vkFreeDescriptorSets(
        VkDevice                                    device,
        VkDescriptorPool                            descriptorPool,
        u32                                         descriptorSetCount,
        const VkDescriptorSet*                      pDescriptorSets) {
    deviceObject := GetDevice(device)
    descriptorPoolObject := GetDescriptorPool(descriptorPool)

    descriptorSets := pDescriptorSets[0:descriptorSetCount]
    for i in (0 .. descriptorSetCount) {
        descriptorSet := descriptorSets[i]
        descriptorSetObject := GetDescriptorSet(descriptorSet)
        assert(descriptorSetObject.device == device)
        State.DescriptorSets[descriptorSet] = null
    }

    return ?
}

cmd void vkUpdateDescriptorSets(
        VkDevice                                    device,
        u32                                         descriptorWriteCount,
        const VkWriteDescriptorSet*                 pDescriptorWrites,
        u32                                         descriptorCopyCount,
        const VkCopyDescriptorSet*                  pDescriptorCopies) {
    deviceObject := GetDevice(device)

    descriptorWrites := pDescriptorWrites[0:descriptorWriteCount]
    for i in (0 .. descriptorWriteCount) {
        descriptorWrite := descriptorWrites[i]
        descriptorWriteObject := GetDescriptorSet(descriptorWrite.dstSet)
        assert(descriptorWriteObject.device == device)
    }

    descriptorCopies := pDescriptorCopies[0:descriptorCopyCount]
    for i in (0 .. descriptorCopyCount) {
        descriptorCopy := descriptorCopies[i]
        descriptorCopyObject := GetDescriptorSet(descriptorCopy.dstSet)
        assert(descriptorCopyObject.device == device)
    }
}


// Framebuffer functions

@threadSafety("system")
cmd VkResult vkCreateFramebuffer(
        VkDevice                                    device,
        const VkFramebufferCreateInfo*              pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkFramebuffer*                              pFramebuffer) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO)
    deviceObject := GetDevice(device)

    framebuffer := ?
    pFramebuffer[0] = framebuffer
    State.Framebuffers[framebuffer] = new!FramebufferObject(device: device)

    return ?
}

@threadSafety("system")
cmd void vkDestroyFramebuffer(
        VkDevice                                    device,
        VkFramebuffer                               framebuffer,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    framebufferObject := GetFramebuffer(framebuffer)
    assert(framebufferObject.device == device)

    State.Framebuffers[framebuffer] = null
}


// Renderpass functions

@threadSafety("system")
cmd VkResult vkCreateRenderPass(
        VkDevice                                    device,
        const VkRenderPassCreateInfo*               pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkRenderPass*                               pRenderPass) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO)
    deviceObject := GetDevice(device)

    renderpass := ?
    pRenderPass[0] = renderpass
    State.RenderPasses[renderpass] = new!RenderPassObject(device: device)

    return ?
}

@threadSafety("system")
cmd void vkDestroyRenderPass(
        VkDevice                                    device,
        VkRenderPass                                renderPass,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    renderPassObject := GetRenderPass(renderPass)
    assert(renderPassObject.device == device)

    State.RenderPasses[renderPass] = null
}

cmd void vkGetRenderAreaGranularity(
        VkDevice                                    device,
        VkRenderPass                                renderPass,
        VkExtent2D*                                 pGranularity) {
    deviceObject := GetDevice(device)
    renderPassObject := GetRenderPass(renderPass)

    granularity := ?
    pGranularity[0] = granularity
}

// Command pool functions

cmd VkResult vkCreateCommandPool(
        VkDevice                                    device,
        const VkCommandPoolCreateInfo*              pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkCommandPool*                              pCommandPool) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO)
    deviceObject := GetDevice(device)

    commandPool := ?
    pCommandPool[0] = commandPool
    State.CommandPools[commandPool] = new!CommandPoolObject(device: device)

    return ?
}

cmd void vkDestroyCommandPool(
        VkDevice                                    device,
        VkCommandPool                               commandPool,
        const VkAllocationCallbacks*                pAllocator) {
    deviceObject := GetDevice(device)
    commandPoolObject := GetCommandPool(commandPool)
    assert(commandPoolObject.device == device)

    State.CommandPools[commandPool] = null
}

cmd VkResult vkResetCommandPool(
        VkDevice                                    device,
        VkCommandPool                               commandPool,
        VkCommandPoolResetFlags                     flags) {
    deviceObject := GetDevice(device)
    commandPoolObject := GetCommandPool(commandPool)
    assert(commandPoolObject.device == device)

    return ?
}

// Command buffer functions

macro void bindCommandBuffer(VkCommandBuffer commandBuffer, any obj, VkDeviceMemory memory) {
    memoryObject := GetDeviceMemory(memory)
    memoryObject.boundCommandBuffers[commandBuffer] = commandBuffer

    commandBufferObject := GetCommandBuffer(commandBuffer)
    commandBufferObject.boundObjects[as!u64(obj)] = memory
}

macro void unbindCommandBuffer(VkCommandBuffer commandBuffer, any obj, VkDeviceMemory memory) {
    memoryObject := GetDeviceMemory(memory)
    memoryObject.boundCommandBuffers[commandBuffer] = null

    commandBufferObject := GetCommandBuffer(commandBuffer)
    commandBufferObject.boundObjects[as!u64(obj)] = null
}

@threadSafety("system")
cmd VkResult vkAllocateCommandBuffers(
        VkDevice                                    device,
        const VkCommandBufferAllocateInfo*          pAllocateInfo,
        VkCommandBuffer*                            pCommandBuffers) {
    assert(pAllocateInfo[0].sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO)

    count := pAllocateInfo[0].commandBufferCount
    commandBuffers := pCommandBuffers[0:count]
    for i in (0 .. count) {
        commandBuffer := ?
        commandBuffers[i] = commandBuffer
        State.CommandBuffers[commandBuffer] = new!CommandBufferObject(device: device)
    }

    return ?
}

@threadSafety("system")
cmd void vkFreeCommandBuffers(
        VkDevice                                    device,
        VkCommandPool                               commandPool,
        u32                                         commandBufferCount,
        const VkCommandBuffer*                      pCommandBuffers) {
    deviceObject := GetDevice(device)

    commandBuffers := pCommandBuffers[0:commandBufferCount]
    for i in (0 .. commandBufferCount) {
        commandBufferObject := GetCommandBuffer(commandBuffers[i])
        assert(commandBufferObject.device == device)
        // TODO: iterate over boundObjects and clear memory bindings
        State.CommandBuffers[commandBuffers[i]] = null
    }
}

@threadSafety("app")
cmd VkResult vkBeginCommandBuffer(
        VkCommandBuffer                             commandBuffer,
        const VkCommandBufferBeginInfo*             pBeginInfo) {
    assert(pBeginInfo.sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO)
    commandBufferObject := GetCommandBuffer(commandBuffer)

    // TODO: iterate over boundObjects and clear memory bindings

    return ?
}

@threadSafety("app")
cmd VkResult vkEndCommandBuffer(
        VkCommandBuffer                             commandBuffer) {
    commandBufferObject := GetCommandBuffer(commandBuffer)

    return ?
}

@threadSafety("app")
cmd VkResult vkResetCommandBuffer(
        VkCommandBuffer                             commandBuffer,
        VkCommandBufferResetFlags                   flags) {
    commandBufferObject := GetCommandBuffer(commandBuffer)

    // TODO: iterate over boundObjects and clear memory bindings

    return ?
}


// Command buffer building functions

@threadSafety("app")
cmd void vkCmdBindPipeline(
        VkCommandBuffer                             commandBuffer,
        VkPipelineBindPoint                         pipelineBindPoint,
        VkPipeline                                  pipeline) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    pipelineObject := GetPipeline(pipeline)
    assert(commandBufferObject.device == pipelineObject.device)

    queue := switch (pipelineBindPoint) {
        case VK_PIPELINE_BIND_POINT_COMPUTE:  VK_QUEUE_COMPUTE_BIT
        case VK_PIPELINE_BIND_POINT_GRAPHICS: VK_QUEUE_GRAPHICS_BIT
    }
    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, queue)
}

@threadSafety("app")
cmd void vkCmdSetViewport(
        VkCommandBuffer                             commandBuffer,
        u32                                         firstViewport,
        u32                                         viewportCount,
        const VkViewport*                           pViewports) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdSetScissor(
        VkCommandBuffer                             commandBuffer,
        u32                                         firstScissor,
        u32                                         scissorCount,
        const VkRect2D*                             pScissors) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdSetLineWidth(
        VkCommandBuffer                             commandBuffer,
        f32                                         lineWidth) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdSetDepthBias(
        VkCommandBuffer                             commandBuffer,
        f32                                         depthBiasConstantFactor,
        f32                                         depthBiasClamp,
        f32                                         depthBiasSlopeFactor) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdSetBlendConstants(
        VkCommandBuffer                             commandBuffer,
        // TODO(jessehall): apic only supports 'const' on pointer types. Using
        // an annotation as a quick hack to pass this to the template without
        // having to modify the AST and semantic model.
        @readonly f32[4]                            blendConstants) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdSetDepthBounds(
        VkCommandBuffer                             commandBuffer,
        f32                                         minDepthBounds,
        f32                                         maxDepthBounds) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdSetStencilCompareMask(
        VkCommandBuffer                             commandBuffer,
        VkStencilFaceFlags                          faceMask,
        u32                                         compareMask) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdSetStencilWriteMask(
        VkCommandBuffer                             commandBuffer,
        VkStencilFaceFlags                          faceMask,
        u32                                         writeMask) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdSetStencilReference(
        VkCommandBuffer                             commandBuffer,
        VkStencilFaceFlags                          faceMask,
        u32                                         reference) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdBindDescriptorSets(
        VkCommandBuffer                             commandBuffer,
        VkPipelineBindPoint                         pipelineBindPoint,
        VkPipelineLayout                            layout,
        u32                                         firstSet,
        u32                                         descriptorSetCount,
        const VkDescriptorSet*                      pDescriptorSets,
        u32                                         dynamicOffsetCount,
        const u32*                                  pDynamicOffsets) {
    commandBufferObject := GetCommandBuffer(commandBuffer)

    descriptorSets := pDescriptorSets[0:descriptorSetCount]
    for i in (0 .. descriptorSetCount) {
        descriptorSet := descriptorSets[i]
        descriptorSetObject := GetDescriptorSet(descriptorSet)
        assert(commandBufferObject.device == descriptorSetObject.device)
    }

    dynamicOffsets := pDynamicOffsets[0:dynamicOffsetCount]
    for i in (0 .. dynamicOffsetCount) {
        dynamicOffset := dynamicOffsets[i]
    }

    queue := switch (pipelineBindPoint) {
        case VK_PIPELINE_BIND_POINT_COMPUTE:  VK_QUEUE_COMPUTE_BIT
        case VK_PIPELINE_BIND_POINT_GRAPHICS: VK_QUEUE_GRAPHICS_BIT
    }
    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, queue)
}

@threadSafety("app")
cmd void vkCmdBindIndexBuffer(
        VkCommandBuffer                             commandBuffer,
        VkBuffer                                    buffer,
        VkDeviceSize                                offset,
        VkIndexType                                 indexType) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    bufferObject := GetBuffer(buffer)
    assert(commandBufferObject.device == bufferObject.device)

    bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdBindVertexBuffers(
        VkCommandBuffer                             commandBuffer,
        u32                                         firstBinding,
        u32                                         bindingCount,
        const VkBuffer*                             pBuffers,
        const VkDeviceSize*                         pOffsets) {
    commandBufferObject := GetCommandBuffer(commandBuffer)

    // TODO: check if not [firstBinding:firstBinding+bindingCount]
    buffers := pBuffers[0:bindingCount]
    offsets := pOffsets[0:bindingCount]
    for i in (0 .. bindingCount) {
        buffer := buffers[i]
        offset := offsets[i]
        bufferObject := GetBuffer(buffer)
        assert(commandBufferObject.device == bufferObject.device)

        bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)
    }

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdDraw(
        VkCommandBuffer                             commandBuffer,
        u32                                         vertexCount,
        u32                                         instanceCount,
        u32                                         firstVertex,
        u32                                         firstInstance) {
    commandBufferObject := GetCommandBuffer(commandBuffer)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdDrawIndexed(
        VkCommandBuffer                             commandBuffer,
        u32                                         indexCount,
        u32                                         instanceCount,
        u32                                         firstIndex,
        s32                                         vertexOffset,
        u32                                         firstInstance) {
    commandBufferObject := GetCommandBuffer(commandBuffer)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdDrawIndirect(
        VkCommandBuffer                             commandBuffer,
        VkBuffer                                    buffer,
        VkDeviceSize                                offset,
        u32                                         drawCount,
        u32                                         stride) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    bufferObject := GetBuffer(buffer)
    assert(commandBufferObject.device == bufferObject.device)

    bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdDrawIndexedIndirect(
        VkCommandBuffer                             commandBuffer,
        VkBuffer                                    buffer,
        VkDeviceSize                                offset,
        u32                                         drawCount,
        u32                                         stride) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    bufferObject := GetBuffer(buffer)
    assert(commandBufferObject.device == bufferObject.device)

    bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdDispatch(
        VkCommandBuffer                             commandBuffer,
        u32                                         groupCountX,
        u32                                         groupCountY,
        u32                                         groupCountZ) {
    commandBufferObject := GetCommandBuffer(commandBuffer)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT)
}

@threadSafety("app")
cmd void vkCmdDispatchIndirect(
        VkCommandBuffer                             commandBuffer,
        VkBuffer                                    buffer,
        VkDeviceSize                                offset) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    bufferObject := GetBuffer(buffer)
    assert(commandBufferObject.device == bufferObject.device)

    bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT)
}

@threadSafety("app")
cmd void vkCmdCopyBuffer(
        VkCommandBuffer                             commandBuffer,
        VkBuffer                                    srcBuffer,
        VkBuffer                                    dstBuffer,
        u32                                         regionCount,
        const VkBufferCopy*                         pRegions) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    srcBufferObject := GetBuffer(srcBuffer)
    dstBufferObject := GetBuffer(dstBuffer)
    assert(commandBufferObject.device == srcBufferObject.device)
    assert(commandBufferObject.device == dstBufferObject.device)

    regions := pRegions[0:regionCount]
    for i in (0 .. regionCount) {
        region := regions[i]
    }

    bindCommandBuffer(commandBuffer, srcBuffer, srcBufferObject.memory)
    bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
}

@threadSafety("app")
cmd void vkCmdCopyImage(
        VkCommandBuffer                             commandBuffer,
        VkImage                                     srcImage,
        VkImageLayout                               srcImageLayout,
        VkImage                                     dstImage,
        VkImageLayout                               dstImageLayout,
        u32                                         regionCount,
        const VkImageCopy*                          pRegions) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    srcImageObject := GetImage(srcImage)
    dstImageObject := GetImage(dstImage)
    assert(commandBufferObject.device == srcImageObject.device)
    assert(commandBufferObject.device == dstImageObject.device)

    regions := pRegions[0:regionCount]
    for i in (0 .. regionCount) {
        region := regions[i]
    }

    bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
    bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
}

@threadSafety("app")
cmd void vkCmdBlitImage(
        VkCommandBuffer                             commandBuffer,
        VkImage                                     srcImage,
        VkImageLayout                               srcImageLayout,
        VkImage                                     dstImage,
        VkImageLayout                               dstImageLayout,
        u32                                         regionCount,
        const VkImageBlit*                          pRegions,
        VkFilter                                    filter) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    srcImageObject := GetImage(srcImage)
    dstImageObject := GetImage(dstImage)
    assert(commandBufferObject.device == srcImageObject.device)
    assert(commandBufferObject.device == dstImageObject.device)

    regions := pRegions[0:regionCount]
    for i in (0 .. regionCount) {
        region := regions[i]
    }

    bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
    bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdCopyBufferToImage(
        VkCommandBuffer                             commandBuffer,
        VkBuffer                                    srcBuffer,
        VkImage                                     dstImage,
        VkImageLayout                               dstImageLayout,
        u32                                         regionCount,
        const VkBufferImageCopy*                    pRegions) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    srcBufferObject := GetBuffer(srcBuffer)
    dstImageObject := GetImage(dstImage)
    assert(commandBufferObject.device == srcBufferObject.device)
    assert(commandBufferObject.device == dstImageObject.device)

    regions := pRegions[0:regionCount]
    for i in (0 .. regionCount) {
        region := regions[i]
    }

    bindCommandBuffer(commandBuffer, srcBuffer, srcBufferObject.memory)
    bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
}

@threadSafety("app")
cmd void vkCmdCopyImageToBuffer(
        VkCommandBuffer                             commandBuffer,
        VkImage                                     srcImage,
        VkImageLayout                               srcImageLayout,
        VkBuffer                                    dstBuffer,
        u32                                         regionCount,
        const VkBufferImageCopy*                    pRegions) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    srcImageObject := GetImage(srcImage)
    dstBufferObject := GetBuffer(dstBuffer)
    assert(commandBufferObject.device == srcImageObject.device)
    assert(commandBufferObject.device == dstBufferObject.device)

    regions := pRegions[0:regionCount]
    for i in (0 .. regionCount) {
        region := regions[i]
    }

    bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
    bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
}

@threadSafety("app")
cmd void vkCmdUpdateBuffer(
        VkCommandBuffer                             commandBuffer,
        VkBuffer                                    dstBuffer,
        VkDeviceSize                                dstOffset,
        VkDeviceSize                                dataSize,
        const void*                                 pData) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    dstBufferObject := GetBuffer(dstBuffer)
    assert(commandBufferObject.device == dstBufferObject.device)

    data := pData[0:dataSize]

    bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
}

@threadSafety("app")
cmd void vkCmdFillBuffer(
        VkCommandBuffer                             commandBuffer,
        VkBuffer                                    dstBuffer,
        VkDeviceSize                                dstOffset,
        VkDeviceSize                                size,
        u32                                         data) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    dstBufferObject := GetBuffer(dstBuffer)
    assert(commandBufferObject.device == dstBufferObject.device)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
}

@threadSafety("app")
cmd void vkCmdClearColorImage(
        VkCommandBuffer                             commandBuffer,
        VkImage                                     image,
        VkImageLayout                               imageLayout,
        const VkClearColorValue*                    pColor,
        u32                                         rangeCount,
        const VkImageSubresourceRange*              pRanges) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    imageObject := GetImage(image)
    assert(commandBufferObject.device == imageObject.device)

    ranges := pRanges[0:rangeCount]
    for i in (0 .. rangeCount) {
        range := ranges[i]
    }

    bindCommandBuffer(commandBuffer, image, imageObject.memory)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdClearDepthStencilImage(
        VkCommandBuffer                             commandBuffer,
        VkImage                                     image,
        VkImageLayout                               imageLayout,
        const VkClearDepthStencilValue*             pDepthStencil,
        u32                                         rangeCount,
        const VkImageSubresourceRange*              pRanges) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    imageObject := GetImage(image)
    assert(commandBufferObject.device == imageObject.device)

    ranges := pRanges[0:rangeCount]
    for i in (0 .. rangeCount) {
        range := ranges[i]
    }

    bindCommandBuffer(commandBuffer, image, imageObject.memory)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdClearAttachments(
        VkCommandBuffer                             commandBuffer,
        u32                                         attachmentCount,
        const VkClearAttachment*                    pAttachments,
        u32                                         rectCount,
        const VkClearRect*                          pRects) {
    commandBufferObject := GetCommandBuffer(commandBuffer)

    rects := pRects[0:rectCount]
    for i in (0 .. rectCount) {
        rect := rects[i]
    }

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdResolveImage(
        VkCommandBuffer                             commandBuffer,
        VkImage                                     srcImage,
        VkImageLayout                               srcImageLayout,
        VkImage                                     dstImage,
        VkImageLayout                               dstImageLayout,
        u32                                         regionCount,
        const VkImageResolve*                       pRegions) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    srcImageObject := GetImage(srcImage)
    dstImageObject := GetImage(dstImage)
    assert(commandBufferObject.device == srcImageObject.device)
    assert(commandBufferObject.device == dstImageObject.device)

    regions := pRegions[0:regionCount]
    for i in (0 .. regionCount) {
        region := regions[i]
    }

    bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
    bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

@threadSafety("app")
cmd void vkCmdSetEvent(
        VkCommandBuffer                             commandBuffer,
        VkEvent                                     event,
        VkPipelineStageFlags                        stageMask) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    eventObject := GetEvent(event)
    assert(commandBufferObject.device == eventObject.device)
}

@threadSafety("app")
cmd void vkCmdResetEvent(
        VkCommandBuffer                             commandBuffer,
        VkEvent                                     event,
        VkPipelineStageFlags                        stageMask) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    eventObject := GetEvent(event)
    assert(commandBufferObject.device == eventObject.device)
}

@threadSafety("app")
cmd void vkCmdWaitEvents(
        VkCommandBuffer                             commandBuffer,
        u32                                         eventCount,
        const VkEvent*                              pEvents,
        VkPipelineStageFlags                        srcStageMask,
        VkPipelineStageFlags                        dstStageMask,
        u32                                         memoryBarrierCount,
        const VkMemoryBarrier*                      pMemoryBarriers,
        u32                                         bufferMemoryBarrierCount,
        const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
        u32                                         imageMemoryBarrierCount,
        const VkImageMemoryBarrier*                 pImageMemoryBarriers) {
    commandBufferObject := GetCommandBuffer(commandBuffer)

    events := pEvents[0:eventCount]
    for i in (0 .. eventCount) {
        event := events[i]
        eventObject := GetEvent(event)
        assert(commandBufferObject.device == eventObject.device)
    }

    memoryBarriers := pMemoryBarriers[0:memoryBarrierCount]
    for i in (0 .. memoryBarrierCount) {
        memoryBarrier := memoryBarriers[i]
    }
    bufferMemoryBarriers := pBufferMemoryBarriers[0:bufferMemoryBarrierCount]
    for i in (0 .. bufferMemoryBarrierCount) {
        bufferMemoryBarrier := bufferMemoryBarriers[i]
        bufferObject := GetBuffer(bufferMemoryBarrier.buffer)
        assert(bufferObject.device == commandBufferObject.device)
    }
    imageMemoryBarriers := pImageMemoryBarriers[0:imageMemoryBarrierCount]
    for i in (0 .. imageMemoryBarrierCount) {
        imageMemoryBarrier := imageMemoryBarriers[i]
        imageObject := GetImage(imageMemoryBarrier.image)
        assert(imageObject.device == commandBufferObject.device)
    }
}

@threadSafety("app")
cmd void vkCmdPipelineBarrier(
        VkCommandBuffer                             commandBuffer,
        VkPipelineStageFlags                        srcStageMask,
        VkPipelineStageFlags                        dstStageMask,
        VkDependencyFlags                           dependencyFlags,
        u32                                         memoryBarrierCount,
        const VkMemoryBarrier*                      pMemoryBarriers,
        u32                                         bufferMemoryBarrierCount,
        const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
        u32                                         imageMemoryBarrierCount,
        const VkImageMemoryBarrier*                 pImageMemoryBarriers) {
    commandBufferObject := GetCommandBuffer(commandBuffer)

    memoryBarriers := pMemoryBarriers[0:memoryBarrierCount]
    for i in (0 .. memoryBarrierCount) {
        memoryBarrier := memoryBarriers[i]
    }
    bufferMemoryBarriers := pBufferMemoryBarriers[0:bufferMemoryBarrierCount]
    for i in (0 .. bufferMemoryBarrierCount) {
        bufferMemoryBarrier := bufferMemoryBarriers[i]
        bufferObject := GetBuffer(bufferMemoryBarrier.buffer)
        assert(bufferObject.device == commandBufferObject.device)
    }
    imageMemoryBarriers := pImageMemoryBarriers[0:imageMemoryBarrierCount]
    for i in (0 .. imageMemoryBarrierCount) {
        imageMemoryBarrier := imageMemoryBarriers[i]
        imageObject := GetImage(imageMemoryBarrier.image)
        assert(imageObject.device == commandBufferObject.device)
    }
}

@threadSafety("app")
cmd void vkCmdBeginQuery(
        VkCommandBuffer                             commandBuffer,
        VkQueryPool                                 queryPool,
        u32                                         query,
        VkQueryControlFlags                         flags) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    queryPoolObject := GetQueryPool(queryPool)
    assert(commandBufferObject.device == queryPoolObject.device)
}

@threadSafety("app")
cmd void vkCmdEndQuery(
        VkCommandBuffer                             commandBuffer,
        VkQueryPool                                 queryPool,
        u32                                         query) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    queryPoolObject := GetQueryPool(queryPool)
    assert(commandBufferObject.device == queryPoolObject.device)
}

@threadSafety("app")
cmd void vkCmdResetQueryPool(
        VkCommandBuffer                             commandBuffer,
        VkQueryPool                                 queryPool,
        u32                                         firstQuery,
        u32                                         queryCount) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    queryPoolObject := GetQueryPool(queryPool)
    assert(commandBufferObject.device == queryPoolObject.device)
}

@threadSafety("app")
cmd void vkCmdWriteTimestamp(
        VkCommandBuffer                             commandBuffer,
        VkPipelineStageFlagBits                     pipelineStage,
        VkQueryPool                                 queryPool,
        u32                                         query) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    queryPoolObject := GetQueryPool(queryPool)
    assert(commandBufferObject.device == queryPoolObject.device)
}

@threadSafety("app")
cmd void vkCmdCopyQueryPoolResults(
        VkCommandBuffer                             commandBuffer,
        VkQueryPool                                 queryPool,
        u32                                         firstQuery,
        u32                                         queryCount,
        VkBuffer                                    dstBuffer,
        VkDeviceSize                                dstOffset,
        VkDeviceSize                                stride,
        VkQueryResultFlags                          flags) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    queryPoolObject := GetQueryPool(queryPool)
    dstBufferObject := GetBuffer(dstBuffer)
    assert(commandBufferObject.device == queryPoolObject.device)
    assert(commandBufferObject.device == dstBufferObject.device)
}

cmd void vkCmdPushConstants(
        VkCommandBuffer                             commandBuffer,
        VkPipelineLayout                            layout,
        VkShaderStageFlags                          stageFlags,
        u32                                         offset,
        u32                                         size,
        const void*                                 pValues) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    layoutObject := GetPipelineLayout(layout)
    assert(commandBufferObject.device == layoutObject.device)
}

@threadSafety("app")
cmd void vkCmdBeginRenderPass(
        VkCommandBuffer                             commandBuffer,
        const VkRenderPassBeginInfo*                pRenderPassBegin,
        VkSubpassContents                           contents) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
    renderPassObject := GetRenderPass(pRenderPassBegin.renderPass)
    framebufferObject := GetFramebuffer(pRenderPassBegin.framebuffer)
    assert(commandBufferObject.device == renderPassObject.device)
    assert(commandBufferObject.device == framebufferObject.device)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

cmd void vkCmdNextSubpass(
        VkCommandBuffer                             commandBuffer,
        VkSubpassContents                           contents) {
    commandBufferObject := GetCommandBuffer(commandBuffer)
}

@threadSafety("app")
cmd void vkCmdEndRenderPass(
        VkCommandBuffer                             commandBuffer) {
    commandBufferObject := GetCommandBuffer(commandBuffer)

    commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}

cmd void vkCmdExecuteCommands(
        VkCommandBuffer                             commandBuffer,
        u32                                         commandBufferCount,
        const VkCommandBuffer*                      pCommandBuffers) {
    commandBufferObject := GetCommandBuffer(commandBuffer)

    commandBuffers := pCommandBuffers[0:commandBufferCount]
    for i in (0 .. commandBufferCount) {
        secondaryCommandBuffer := commandBuffers[i]
        secondaryCommandBufferObject := GetCommandBuffer(secondaryCommandBuffer)
        assert(commandBufferObject.device == secondaryCommandBufferObject.device)
    }
}

//@vulkan1_1 functions

@vulkan1_1
cmd VkResult vkEnumerateInstanceVersion(
        u32*                                            pApiVersion) {
    return ?
}

@vulkan1_1
cmd VkResult vkBindBufferMemory2(
        VkDevice                                        device,
        u32                                             bindInfoCount,
        const VkBindBufferMemoryInfo*                   pBindInfos) {
    return ?
}

@vulkan1_1
cmd VkResult vkBindImageMemory2(
        VkDevice                                        device,
        u32                                             bindInfoCount,
        const VkBindImageMemoryInfo*                    pBindInfos) {
    return ?
}

@vulkan1_1
cmd void vkGetDeviceGroupPeerMemoryFeatures(
        VkDevice                                    device,
        u32                                         heapIndex,
        u32                                         localDeviceIndex,
        u32                                         remoteDeviceIndex,
        VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures) {
}

@vulkan1_1
cmd void vkCmdSetDeviceMask(
        VkCommandBuffer                             commandBuffer,
        u32                                         deviceMask) {
}

@vulkan1_1
cmd void vkCmdDispatchBase(
        VkCommandBuffer                             commandBuffer,
        u32                                         baseGroupX,
        u32                                         baseGroupY,
        u32                                         baseGroupZ,
        u32                                         groupCountX,
        u32                                         groupCountY,
        u32                                         groupCountZ) {
}

@threadSafety("system")
@vulkan1_1
cmd VkResult vkEnumeratePhysicalDeviceGroups(
        VkInstance                                  instance,
        u32*                                        pPhysicalDeviceGroupCount,
        VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties) {
    instanceObject := GetInstance(instance)

    physicalDeviceGroupCount := as!u32(?)
    pPhysicalDeviceGroupCount[0] = physicalDeviceGroupCount
    physicalDevices := pPhysicalDeviceGroupProperties[0:physicalDeviceGroupCount]

    for i in (0 .. physicalDeviceGroupCount) {
        physicalDevice := ?
        physicalDevices[i] = physicalDevice
        if !(physicalDevice in State.PhysicalDevices) {
            State.PhysicalDevices[physicalDevice] = new!PhysicalDeviceObject(instance: instance)
        }
    }

    return ?
}

@vulkan1_1
cmd void vkGetImageMemoryRequirements2(
        VkDevice                                    device,
        const VkImageMemoryRequirementsInfo2*       pInfo,
        VkMemoryRequirements2*                      pMemoryRequirements) {
}

@vulkan1_1
cmd void vkGetBufferMemoryRequirements2(
        VkDevice                                    device,
        const VkBufferMemoryRequirementsInfo2*      pInfo,
        VkMemoryRequirements2*                      pMemoryRequirements) {
}

@vulkan1_1
cmd void vkGetImageSparseMemoryRequirements2(
        VkDevice                                        device,
        const VkImageSparseMemoryRequirementsInfo2*     pInfo,
        u32*                                            pSparseMemoryRequirementCount,
        VkSparseImageMemoryRequirements2*               pSparseMemoryRequirements) {
}

@vulkan1_1
cmd void vkGetPhysicalDeviceFeatures2(
        VkPhysicalDevice                            physicalDevice,
        VkPhysicalDeviceFeatures2*                  pFeatures) {
}

@vulkan1_1
cmd void vkGetPhysicalDeviceProperties2(
        VkPhysicalDevice                            physicalDevice,
        VkPhysicalDeviceProperties2*                pProperties) {
}

@vulkan1_1
cmd void vkGetPhysicalDeviceFormatProperties2(
        VkPhysicalDevice                            physicalDevice,
        VkFormat                                    format,
        VkFormatProperties2*                        pFormatProperties) {
}

@vulkan1_1
cmd VkResult vkGetPhysicalDeviceImageFormatProperties2(
        VkPhysicalDevice                            physicalDevice,
        const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
        VkImageFormatProperties2*                   pImageFormatProperties) {
    return ?
}

@vulkan1_1
cmd void vkGetPhysicalDeviceQueueFamilyProperties2(
        VkPhysicalDevice                            physicalDevice,
        u32*                                        pQueueFamilyPropertyCount,
        VkQueueFamilyProperties2*                   pQueueFamilyProperties) {
}

@vulkan1_1
cmd void vkGetPhysicalDeviceMemoryProperties2(
        VkPhysicalDevice                            physicalDevice,
        VkPhysicalDeviceMemoryProperties2*          pMemoryProperties) {
}

@vulkan1_1
cmd void vkGetPhysicalDeviceSparseImageFormatProperties2(
        VkPhysicalDevice                                    physicalDevice,
        const VkPhysicalDeviceSparseImageFormatInfo2*       pFormatInfo,
        u32*                                                pPropertyCount,
        VkSparseImageFormatProperties2*                     pProperties) {
}

@vulkan1_1
cmd void vkTrimCommandPool(
        VkDevice                                    device,
        VkCommandPool                               commandPool,
        VkCommandPoolTrimFlags                      flags) {
}


@vulkan1_1
cmd void vkGetDeviceQueue2(
        VkDevice                                    device,
        const VkDeviceQueueInfo2*                   pQueueInfo,
        VkQueue*                                    pQueue) {
    deviceObject := GetDevice(device)

    queue := ?
    pQueue[0] = queue

    if !(queue in State.Queues) {
        State.Queues[queue] = new!QueueObject(device: device)
    }
}

@vulkan1_1
cmd VkResult vkCreateSamplerYcbcrConversion(
        VkDevice                                        device,
        const VkSamplerYcbcrConversionCreateInfo*       pCreateInfo,
        const VkAllocationCallbacks*                    pAllocator,
        VkSamplerYcbcrConversion*                       pYcbcrConversion) {
    return ?
}

@vulkan1_1
cmd void vkDestroySamplerYcbcrConversion(
        VkDevice                                        device,
        VkSamplerYcbcrConversion                        ycbcrConversion,
        const VkAllocationCallbacks*                    pAllocator) {
}

@vulkan1_1
cmd VkResult vkCreateDescriptorUpdateTemplate(
        VkDevice                                    device,
        const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate) {
    return ?
}

@vulkan1_1
cmd void vkDestroyDescriptorUpdateTemplate(
        VkDevice                                    device,
        VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
        const VkAllocationCallbacks*                pAllocator) {
}

@vulkan1_1
cmd void vkUpdateDescriptorSetWithTemplate(
        VkDevice                                    device,
        VkDescriptorSet                             descriptorSet,
        VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
        const void*                                 pData) {
}

@vulkan1_1
cmd void vkGetPhysicalDeviceExternalBufferProperties(
        VkPhysicalDevice                                physicalDevice,
        const VkPhysicalDeviceExternalBufferInfo*       pExternalBufferInfo,
        VkExternalBufferProperties*                     pExternalBufferProperties) {
}

@vulkan1_1
cmd void vkGetPhysicalDeviceExternalFenceProperties(
        VkPhysicalDevice                            physicalDevice,
        const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
        VkExternalFenceProperties*                  pExternalFenceProperties) {
}

@vulkan1_1
cmd void vkGetPhysicalDeviceExternalSemaphoreProperties(
        VkPhysicalDevice                                physicalDevice,
        const VkPhysicalDeviceExternalSemaphoreInfo*    pExternalSemaphoreInfo,
        VkExternalSemaphoreProperties*                  pExternalSemaphoreProperties) {
}

@vulkan1_1
cmd void vkGetDescriptorSetLayoutSupport(
        VkDevice                                    device,
        const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
        VkDescriptorSetLayoutSupport*               pSupport) {
}


@extension("VK_KHR_surface") // 1
cmd void vkDestroySurfaceKHR(
        VkInstance                                  instance,
        VkSurfaceKHR                                surface,
        const VkAllocationCallbacks*                pAllocator) {
    instanceObject := GetInstance(instance)
    surfaceObject := GetSurface(surface)
    assert(surfaceObject.instance == instance)

    State.Surfaces[surface] = null
}

@extension("VK_KHR_surface") // 1
cmd VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
        VkPhysicalDevice                            physicalDevice,
        u32                                         queueFamilyIndex,
        VkSurfaceKHR                                surface,
        VkBool32*                                   pSupported) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)

    return ?
}

@extension("VK_KHR_surface") // 1
cmd VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
        VkPhysicalDevice                            physicalDevice,
        VkSurfaceKHR                                surface,
        VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)

    surfaceCapabilities := ?
    pSurfaceCapabilities[0] = surfaceCapabilities

    return ?
}

@extension("VK_KHR_surface") // 1
cmd VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(
        VkPhysicalDevice                            physicalDevice,
        VkSurfaceKHR                                surface,
        u32*                                        pSurfaceFormatCount,
        VkSurfaceFormatKHR*                         pSurfaceFormats) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)

    count := as!u32(?)
    pSurfaceFormatCount[0] = count
    surfaceFormats := pSurfaceFormats[0:count]

    for i in (0 .. count) {
        surfaceFormat := ?
        surfaceFormats[i] = surfaceFormat
    }

    return ?
}

@extension("VK_KHR_surface") // 1
cmd VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
        VkPhysicalDevice                            physicalDevice,
        VkSurfaceKHR                                surface,
        u32*                                        pPresentModeCount,
        VkPresentModeKHR*                           pPresentModes) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)

    count := as!u32(?)
    pPresentModeCount[0] = count
    presentModes := pPresentModes[0:count]

    for i in (0 .. count) {
        presentMode := ?
        presentModes[i] = presentMode
    }

    return ?
}

@extension("VK_KHR_swapchain") // 2
cmd VkResult vkCreateSwapchainKHR(
        VkDevice                                 device,
        const VkSwapchainCreateInfoKHR*          pCreateInfo,
        const VkAllocationCallbacks*             pAllocator,
        VkSwapchainKHR*                          pSwapchain) {
    assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR)
    deviceObject := GetDevice(device)

    swapchain := ?
    pSwapchain[0] = swapchain
    State.Swapchains[swapchain] = new!SwapchainObject(device: device)

    return ?
}

@extension("VK_KHR_swapchain") // 2
cmd void vkDestroySwapchainKHR(
        VkDevice                                 device,
        VkSwapchainKHR                           swapchain,
        const VkAllocationCallbacks*             pAllocator) {
    deviceObject := GetDevice(device)
    swapchainObject := GetSwapchain(swapchain)
    assert(swapchainObject.device == device)

    State.Swapchains[swapchain] = null
}

@extension("VK_KHR_swapchain") // 2
cmd VkResult vkGetSwapchainImagesKHR(
        VkDevice                                 device,
        VkSwapchainKHR                           swapchain,
        u32*                                     pSwapchainImageCount,
        VkImage*                                 pSwapchainImages) {
    deviceObject := GetDevice(device)

    count := as!u32(?)
    pSwapchainImageCount[0] = count
    swapchainImages := pSwapchainImages[0:count]

    for i in (0 .. count) {
        swapchainImage := ?
        swapchainImages[i] = swapchainImage
        State.Images[swapchainImage] = new!ImageObject(device: device)
    }

    return ?
}

@extension("VK_KHR_swapchain") // 2
cmd VkResult vkAcquireNextImageKHR(
        VkDevice                                 device,
        VkSwapchainKHR                           swapchain,
        u64                                      timeout,
        VkSemaphore                              semaphore,
        VkFence                                  fence,
        u32*                                     pImageIndex) {
    deviceObject := GetDevice(device)
    swapchainObject := GetSwapchain(swapchain)

    imageIndex := ?
    pImageIndex[0] = imageIndex

    return ?
}

@extension("VK_KHR_swapchain") // 2
cmd VkResult vkQueuePresentKHR(
        VkQueue                                  queue,
        const VkPresentInfoKHR*                  pPresentInfo) {
    queueObject := GetQueue(queue)

    presentInfo := ?
    pPresentInfo[0] = presentInfo

    return ?
}

@vulkan1_1
@extension("VK_KHR_swapchain") // 2
cmd VkResult vkGetDeviceGroupPresentCapabilitiesKHR(
        VkDevice                                    device,
        VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities) {
    return ?
}

@vulkan1_1
@extension("VK_KHR_swapchain") // 2
cmd VkResult vkGetDeviceGroupSurfacePresentModesKHR(
        VkDevice                                    device,
        VkSurfaceKHR                                surface,
        VkDeviceGroupPresentModeFlagsKHR*           pModes) {
    return ?
}

@vulkan1_1
@extension("VK_KHR_swapchain") // 2
cmd VkResult vkGetPhysicalDevicePresentRectanglesKHR(
        VkPhysicalDevice                            physicalDevice,
        VkSurfaceKHR                                surface,
        u32*                                        pRectCount,
        VkRect2D*                                   pRects) {
    return ?
}

@vulkan1_1
@extension("VK_KHR_swapchain") // 2
cmd VkResult vkAcquireNextImage2KHR(
        VkDevice                                    device,
        const VkAcquireNextImageInfoKHR*            pAcquireInfo,
        u32*                                        pImageIndex) {
    return ?
}

@extension("VK_KHR_display") // 3
cmd VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
        VkPhysicalDevice                        physicalDevice,
        u32*                                    pPropertyCount,
        VkDisplayPropertiesKHR*                 pProperties) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
    return ?
}

@extension("VK_KHR_display") // 3
cmd VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
        VkPhysicalDevice                        physicalDevice,
        u32*                                    pPropertyCount,
        VkDisplayPlanePropertiesKHR*            pProperties) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
    return ?
}

@extension("VK_KHR_display") // 3
cmd VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
        VkPhysicalDevice                        physicalDevice,
        u32                                     planeIndex,
        u32*                                    pDisplayCount,
        VkDisplayKHR*                           pDisplays) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
    return ?
}

@extension("VK_KHR_display") // 3
cmd VkResult vkGetDisplayModePropertiesKHR(
        VkPhysicalDevice                        physicalDevice,
        VkDisplayKHR                            display,
        u32*                                    pPropertyCount,
        VkDisplayModePropertiesKHR*             pProperties) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
    return ?
}

@extension("VK_KHR_display") // 3
cmd VkResult vkCreateDisplayModeKHR(
        VkPhysicalDevice                        physicalDevice,
        VkDisplayKHR                            display,
        const VkDisplayModeCreateInfoKHR*       pCreateInfo,
        const VkAllocationCallbacks*            pAllocator,
        VkDisplayModeKHR*                       pMode) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
    return ?
}

@extension("VK_KHR_display") // 3
cmd VkResult vkGetDisplayPlaneCapabilitiesKHR(
        VkPhysicalDevice                        physicalDevice,
        VkDisplayModeKHR                        mode,
        u32                                     planeIndex,
        VkDisplayPlaneCapabilitiesKHR*          pCapabilities) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
    return ?
}

@extension("VK_KHR_display") // 3
cmd VkResult vkCreateDisplayPlaneSurfaceKHR(
        VkInstance                              instance,
        const VkDisplaySurfaceCreateInfoKHR*    pCreateInfo,
        const VkAllocationCallbacks*            pAllocator,
        VkSurfaceKHR*                           pSurface) {
    return ?
}

@extension("VK_KHR_display_swapchain") // 4
cmd VkResult vkCreateSharedSwapchainsKHR(
        VkDevice                                device,
        u32                                     swapchainCount,
        const VkSwapchainCreateInfoKHR*         pCreateInfos,
        const VkAllocationCallbacks*            pAllocator,
        VkSwapchainKHR*                         pSwapchains) {
    return ?
}

@extension("VK_KHR_xlib_surface") // 5
cmd VkResult vkCreateXlibSurfaceKHR(
        VkInstance                              instance,
        const VkXlibSurfaceCreateInfoKHR*       pCreateInfo,
        const VkAllocationCallbacks*            pAllocator,
        VkSurfaceKHR*                           pSurface) {
    instanceObject := GetInstance(instance)
    return ?
}

@extension("VK_KHR_xlib_surface") // 5
cmd VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(
        VkPhysicalDevice                        physicalDevice,
        u32                                     queueFamilyIndex,
        platform.Display*                       dpy,
        platform.VisualID                       visualID) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
    return ?
}

@extension("VK_KHR_xcb_surface") // 6
cmd VkResult vkCreateXcbSurfaceKHR(
        VkInstance                              instance,
        const VkXcbSurfaceCreateInfoKHR*        pCreateInfo,
        const VkAllocationCallbacks*            pAllocator,
        VkSurfaceKHR*                           pSurface) {
    instanceObject := GetInstance(instance)
    return ?
}

@extension("VK_KHR_xcb_surface") // 6
cmd VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR(
        VkPhysicalDevice                        physicalDevice,
        u32                                     queueFamilyIndex,
        platform.xcb_connection_t*              connection,
        platform.xcb_visualid_t                 visual_id) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
    return ?
}

@extension("VK_KHR_wayland_surface") // 7
cmd VkResult vkCreateWaylandSurfaceKHR(
        VkInstance                              instance,
        const VkWaylandSurfaceCreateInfoKHR*    pCreateInfo,
        const VkAllocationCallbacks*            pAllocator,
        VkSurfaceKHR*                           pSurface) {
    instanceObject := GetInstance(instance)
    return ?
}

@extension("VK_KHR_wayland_surface") // 7
cmd VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR(
        VkPhysicalDevice                        physicalDevice,
        u32                                     queueFamilyIndex,
        platform.wl_display*                    display) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
    return ?
}

@extension("VK_KHR_mir_surface") // 8
cmd VkResult vkCreateMirSurfaceKHR(
        VkInstance                              instance,
        const VkMirSurfaceCreateInfoKHR*        pCreateInfo,
        const VkAllocationCallbacks*            pAllocator,
        VkSurfaceKHR*                           pSurface) {
    instanceObject := GetInstance(instance)
    return ?
}

@extension("VK_KHR_mir_surface") // 8
cmd VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR(
        VkPhysicalDevice                        physicalDevice,
        u32                                     queueFamilyIndex,
        platform.MirConnection*                 connection) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
    return ?
}

@extension("VK_KHR_android_surface") // 9
cmd VkResult vkCreateAndroidSurfaceKHR(
        VkInstance                              instance,
        const VkAndroidSurfaceCreateInfoKHR*    pCreateInfo,
        const VkAllocationCallbacks*            pAllocator,
        VkSurfaceKHR*                           pSurface) {
    instanceObject := GetInstance(instance)
    return ?
}

@extension("VK_KHR_win32_surface") // 10
cmd VkResult vkCreateWin32SurfaceKHR(
        VkInstance                              instance,
        const VkWin32SurfaceCreateInfoKHR*      pCreateInfo,
        const VkAllocationCallbacks*            pAllocator,
        VkSurfaceKHR*                           pSurface) {
    instanceObject := GetInstance(instance)
    return ?
}

@extension("VK_KHR_win32_surface") // 10
cmd VkResult vkGetPhysicalDeviceWin32PresentationSupportKHR(
        VkPhysicalDevice                        physicalDevice,
        u32                                     queueFamilyIndex) {
    physicalDeviceObject := GetPhysicalDevice(physicalDevice)
    return ?
}

@extension("VK_ANDROID_native_buffer") // 11
@optional
cmd VkResult vkGetSwapchainGrallocUsageANDROID(
        VkDevice                                device,
        VkFormat                                format,
        VkImageUsageFlags                       imageUsage,
        s32*                                    grallocUsage) {
    return ?
}

@extension("VK_ANDROID_native_buffer") // 11
@optional
cmd VkResult vkGetSwapchainGrallocUsage2ANDROID(
        VkDevice                                device,
        VkFormat                                format,
        VkImageUsageFlags                       imageUsage,
        VkSwapchainImageUsageFlagsANDROID       swapchainImageUsage,
        u64*                                    grallocConsumerUsage,
        u64*                                    grallocProducerUsage) {
    return ?
}

@extension("VK_ANDROID_native_buffer") // 11
cmd VkResult vkAcquireImageANDROID(
        VkDevice                                device,
        VkImage                                 image,
        int                                     nativeFenceFd,
        VkSemaphore                             semaphore,
        VkFence                                 fence) {
    return ?
}

@extension("VK_ANDROID_native_buffer") // 11
cmd VkResult vkQueueSignalReleaseImageANDROID(
        VkQueue                                 queue,
        u32                                     waitSemaphoreCount,
        const VkSemaphore*                      pWaitSemaphores,
        VkImage                                 image,
        int*                                    pNativeFenceFd) {
    return ?
}

@extension("VK_EXT_debug_report") // 12
@external type void* PFN_vkDebugReportCallbackEXT
@extension("VK_EXT_debug_report") // 12
@pfn cmd VkBool32 vkDebugReportCallbackEXT(
        VkDebugReportFlagsEXT                   flags,
        VkDebugReportObjectTypeEXT              objectType,
        u64                                     object,
        platform.size_t                         location,
        s32                                     messageCode,
        const char*                             pLayerPrefix,
        const char*                             pMessage,
        void*                                   pUserData) {
    return ?
}

@extension("VK_EXT_debug_report") // 12
cmd VkResult vkCreateDebugReportCallbackEXT(
        VkInstance                                  instance,
        const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkDebugReportCallbackEXT*                   pCallback) {
    return ?
}

@extension("VK_EXT_debug_report") // 12
cmd void vkDestroyDebugReportCallbackEXT(
        VkInstance                                  instance,
        VkDebugReportCallbackEXT                    callback,
        const VkAllocationCallbacks*                pAllocator) {
}

@extension("VK_EXT_debug_report") // 12
cmd void vkDebugReportMessageEXT(
        VkInstance                                  instance,
        VkDebugReportFlagsEXT                       flags,
        VkDebugReportObjectTypeEXT                  objectType,
        u64                                         object,
        platform.size_t                             location,
        s32                                         messageCode,
        const char*                                 pLayerPrefix,
        const char*                                 pMessage) {
}

@extension("VK_EXT_debug_marker") // 23
cmd VkResult vkDebugMarkerSetObjectTagEXT(
        VkDevice                                    device,
        const VkDebugMarkerObjectTagInfoEXT*        pTagInfo) {
    return ?
}

@extension("VK_EXT_debug_marker") // 23
cmd VkResult vkDebugMarkerSetObjectNameEXT(
        VkDevice                                    device,
        const VkDebugMarkerObjectNameInfoEXT*       pNameInfo) {
    return ?
}

@extension("VK_EXT_debug_marker") // 23
cmd void vkCmdDebugMarkerBeginEXT(
        VkCommandBuffer                             commandBuffer,
        const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo) {
}

@extension("VK_EXT_debug_marker") // 23
cmd void vkCmdDebugMarkerEndEXT(
        VkCommandBuffer                             commandBuffer) {
}

@extension("VK_EXT_debug_marker") // 23
cmd void vkCmdDebugMarkerInsertEXT(
        VkCommandBuffer                             commandBuffer,
        const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo) {
}

@extension("VK_EXT_transform_feedback") // 29
cmd void vkCmdBindTransformFeedbackBuffersEXT(
        VkCommandBuffer                             commandBuffer,
        u32                                         firstBinding,
        u32                                         bindingCount,
        const VkBuffer*                             pBuffers,
        const VkDeviceSize*                         pOffsets,
        const VkDeviceSize*                         pSizes) {
}

@extension("VK_EXT_transform_feedback") // 29
cmd void vkCmdBeginTransformFeedbackEXT(
        VkCommandBuffer                             commandBuffer,
        u32                                         firstCounterBuffer,
        u32                                         counterBufferCount,
        const VkBuffer*                             pCounterBuffers,
        const VkDeviceSize*                         pCounterBufferOffsets) {
}

@extension("VK_EXT_transform_feedback") // 29
cmd void vkCmdEndTransformFeedbackEXT(
        VkCommandBuffer                             commandBuffer,
        u32                                         firstCounterBuffer,
        u32                                         counterBufferCount,
        const VkBuffer*                             pCounterBuffers,
        const VkDeviceSize*                         pCounterBufferOffsets) {
}

@extension("VK_EXT_transform_feedback") // 29
cmd void vkCmdBeginQueryIndexedEXT(
        VkCommandBuffer                             commandBuffer,
        VkQueryPool                                 queryPool,
        u32                                         query,
        VkQueryControlFlags                         flags,
        u32                                         index) {
}

@extension("VK_EXT_transform_feedback") // 29
cmd void vkCmdEndQueryIndexedEXT(
        VkCommandBuffer                             commandBuffer,
        VkQueryPool                                 queryPool,
        u32                                         query,
        u32                                         index) {
}

@extension("VK_EXT_transform_feedback") // 29
cmd void vkCmdDrawIndirectByteCountEXT(
        VkCommandBuffer                             commandBuffer,
        u32                                         instanceCount,
        u32                                         firstInstance,
        VkBuffer                                    counterBuffer,
        VkDeviceSize                                counterBufferOffset,
        u32                                         counterOffset,
        u32                                         vertexStride) {
}

@extension("VK_AMD_draw_indirect_count") // 34
cmd void vkCmdDrawIndirectCountAMD(
        VkCommandBuffer                             commandBuffer,
        VkBuffer                                    buffer,
        VkDeviceSize                                offset,
        VkBuffer                                    countBuffer,
        VkDeviceSize                                countBufferOffset,
        u32                                         maxDrawCount,
        u32                                         stride) {
}

@extension("VK_AMD_draw_indirect_count") // 34
cmd void vkCmdDrawIndexedIndirectCountAMD(
        VkCommandBuffer                             commandBuffer,
        VkBuffer                                    buffer,
        VkDeviceSize                                offset,
        VkBuffer                                    countBuffer,
        VkDeviceSize                                countBufferOffset,
        u32                                         maxDrawCount,
        u32                                         stride) {
}

@extension("VK_AMD_shader_info") // 43
cmd VkResult vkGetShaderInfoAMD(
        VkDevice                                    device,
        VkPipeline                                  pipeline,
        VkShaderStageFlagBits                       shaderStage,
        VkShaderInfoTypeAMD                         infoType,
        platform.size_t*                            pInfoSize,
        void*                                       pInfo) {
    return ?
}

@extension("VK_NV_external_memory_capabilities") // 56
cmd VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
        VkPhysicalDevice                            physicalDevice,
        VkFormat                                    format,
        VkImageType                                 type,
        VkImageTiling                               tiling,
        VkImageUsageFlags                           usage,
        VkImageCreateFlags                          flags,
        VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
        VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties) {
    return ?
}

@extension("VK_NV_external_memory_win32") // 58
cmd VkResult vkGetMemoryWin32HandleNV(
        VkDevice                                    device,
        VkDeviceMemory                              memory,
        VkExternalMemoryHandleTypeFlagsNV           handleType,
        platform.HANDLE*                            pHandle) {
    return ?
}

@extension("VK_KHR_get_physical_device_properties2") // 60
cmd void vkGetPhysicalDeviceFeatures2KHR(
        VkPhysicalDevice                            physicalDevice,
        VkPhysicalDeviceFeatures2KHR*               pFeatures) {
}

@extension("VK_KHR_get_physical_device_properties2") // 60
cmd void vkGetPhysicalDeviceProperties2KHR(
        VkPhysicalDevice                            physicalDevice,
        VkPhysicalDeviceProperties2KHR*             pProperties) {
}

@extension("VK_KHR_get_physical_device_properties2") // 60
cmd void vkGetPhysicalDeviceFormatProperties2KHR(
        VkPhysicalDevice                            physicalDevice,
        VkFormat                                    format,
        VkFormatProperties2KHR*                     pFormatProperties) {
}

@extension("VK_KHR_get_physical_device_properties2") // 60
cmd VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(
        VkPhysicalDevice                            physicalDevice,
        const VkPhysicalDeviceImageFormatInfo2KHR*  pImageFormatInfo,
        VkImageFormatProperties2KHR*                pImageFormatProperties) {
    return ?
}

@extension("VK_KHR_get_physical_device_properties2") // 60
cmd void vkGetPhysicalDeviceQueueFamilyProperties2KHR(
        VkPhysicalDevice                            physicalDevice,
        u32*                                        pQueueFamilyPropertyCount,
        VkQueueFamilyProperties2KHR*                pQueueFamilyProperties) {
}

@extension("VK_KHR_get_physical_device_properties2") // 60
cmd void vkGetPhysicalDeviceMemoryProperties2KHR(
        VkPhysicalDevice                            physicalDevice,
        VkPhysicalDeviceMemoryProperties2KHR*       pMemoryProperties) {
}

@extension("VK_KHR_get_physical_device_properties2") // 60
cmd void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
        VkPhysicalDevice                                    physicalDevice,
        const VkPhysicalDeviceSparseImageFormatInfo2KHR*    pFormatInfo,
        u32*                                                pPropertyCount,
        VkSparseImageFormatProperties2KHR*                  pProperties) {
}

@extension("VK_KHR_device_group") // 61
cmd void vkGetDeviceGroupPeerMemoryFeaturesKHR(
        VkDevice                                    device,
        u32                                         heapIndex,
        u32                                         localDeviceIndex,
        u32                                         remoteDeviceIndex,
        VkPeerMemoryFeatureFlagsKHR*                pPeerMemoryFeatures) {
}

@extension("VK_KHR_device_group") // 61
cmd void vkCmdSetDeviceMaskKHR(
        VkCommandBuffer                             commandBuffer,
        u32                                         deviceMask) {
}


@extension("VK_KHR_device_group") // 61
cmd void vkCmdDispatchBaseKHR(
        VkCommandBuffer                             commandBuffer,
        u32                                         baseGroupX,
        u32                                         baseGroupY,
        u32                                         baseGroupZ,
        u32                                         groupCountX,
        u32                                         groupCountY,
        u32                                         groupCountZ) {
}

@extension("VK_NN_vi_surface") // 63
cmd VkResult vkCreateViSurfaceNN(
        VkInstance                                  instance,
        const VkViSurfaceCreateInfoNN*              pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkSurfaceKHR*                               pSurface) {
    return ?
}

@extension("VK_KHR_maintenance1") // 70
cmd void vkTrimCommandPoolKHR(
        VkDevice                                    device,
        VkCommandPool                               commandPool,
        VkCommandPoolTrimFlagsKHR                   flags) {
}

@extension("VK_KHR_device_group_creation") // 71
@threadSafety("system")
cmd VkResult vkEnumeratePhysicalDeviceGroupsKHR(
        VkInstance                                  instance,
        u32*                                        pPhysicalDeviceGroupCount,
        VkPhysicalDeviceGroupPropertiesKHR*         pPhysicalDeviceGroupProperties) {
    instanceObject := GetInstance(instance)

    physicalDeviceGroupCount := as!u32(?)
    pPhysicalDeviceGroupCount[0] = physicalDeviceGroupCount
    physicalDevices := pPhysicalDeviceGroupProperties[0:physicalDeviceGroupCount]

    for i in (0 .. physicalDeviceGroupCount) {
        physicalDevice := ?
        physicalDevices[i] = physicalDevice
        if !(physicalDevice in State.PhysicalDevices) {
            State.PhysicalDevices[physicalDevice] = new!PhysicalDeviceObject(instance: instance)
        }
    }

    return ?
}

@extension("VK_KHR_external_memory_capabilities") // 72
cmd void vkGetPhysicalDeviceExternalBufferPropertiesKHR(
        VkPhysicalDevice                                physicalDevice,
        const VkPhysicalDeviceExternalBufferInfoKHR*    pExternalBufferInfo,
        VkExternalBufferPropertiesKHR*                  pExternalBufferProperties) {
}

@extension("VK_KHR_external_memory_win32") // 74
cmd VkResult vkGetMemoryWin32HandleKHR(
        VkDevice                                    device,
        const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
        platform.HANDLE*                            pHandle) {
    return ?
}

@extension("VK_KHR_external_memory_win32") // 74
cmd VkResult vkGetMemoryWin32HandlePropertiesKHR(
        VkDevice                                    device,
        VkExternalMemoryHandleTypeFlagBitsKHR       handleType,
        platform.HANDLE                             handle,
        VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties) {
    return ?
}

@extension("VK_KHR_external_memory_fd") // 75
cmd VkResult vkGetMemoryFdKHR(
        VkDevice                                    device,
        const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
        s32*                                        pFd) {
    return ?
}

@extension("VK_KHR_external_memory_fd") // 75
cmd VkResult vkGetMemoryFdPropertiesKHR(
        VkDevice                                    device,
        VkExternalMemoryHandleTypeFlagBitsKHR       handleType,
        s32                                         fd,
        VkMemoryFdPropertiesKHR*                    pMemoryFdProperties) {
    return ?
}

@extension("VK_KHR_external_semaphore_capabilities") // 77
cmd void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
        VkPhysicalDevice                            physicalDevice,
        const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo,
        VkExternalSemaphorePropertiesKHR*           pExternalSemaphoreProperties) {
}

@extension("VK_KHR_external_semaphore_win32") // 79
cmd VkResult vkImportSemaphoreWin32HandleKHR(
        VkDevice                                    device,
        const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo) {
    return ?
}

@extension("VK_KHR_external_semaphore_win32") // 79
cmd VkResult vkGetSemaphoreWin32HandleKHR(
        VkDevice                                    device,
        const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
        platform.HANDLE*                            pHandle) {
    return ?
}

@extension("VK_KHR_external_semaphore_fd") // 80
cmd VkResult vkImportSemaphoreFdKHR(
        VkDevice                                    device,
        const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo) {
    return ?
}

@extension("VK_KHR_external_semaphore_fd") // 80
cmd VkResult vkGetSemaphoreFdKHR(
        VkDevice                                    device,
        const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
        s32*                                        pFd) {
    return ?
}

@extension("VK_KHR_push_descriptor") // 81
cmd void vkCmdPushDescriptorSetKHR(
        VkCommandBuffer                             commandBuffer,
        VkPipelineBindPoint                         pipelineBindPoint,
        VkPipelineLayout                            layout,
        u32                                         set,
        u32                                         descriptorWriteCount,
        const VkWriteDescriptorSet*                 pDescriptorWrites) {
}

@extension("VK_EXT_conditional_rendering") // 82
cmd void vkCmdBeginConditionalRenderingEXT(
        VkCommandBuffer                             commandBuffer,
        const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin) {
}

@extension("VK_EXT_conditional_rendering") // 82
cmd void vkCmdEndConditionalRenderingEXT(
        VkCommandBuffer                             commandBuffer) {
}

@extension("VK_KHR_descriptor_update_template") // 86
cmd VkResult vkCreateDescriptorUpdateTemplateKHR(
        VkDevice                                    device,
        const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkDescriptorUpdateTemplateKHR*              pDescriptorUpdateTemplate) {
    return ?
}

@extension("VK_KHR_descriptor_update_template") // 86
cmd void vkDestroyDescriptorUpdateTemplateKHR(
        VkDevice                                    device,
        VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
        const VkAllocationCallbacks*                pAllocator) {
}

@extension("VK_KHR_descriptor_update_template") // 86
cmd void vkUpdateDescriptorSetWithTemplateKHR(
        VkDevice                                    device,
        VkDescriptorSet                             descriptorSet,
        VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
        const void*                                 pData) {
}

@extension("VK_KHR_descriptor_update_template") // 86
cmd void vkCmdPushDescriptorSetWithTemplateKHR(
        VkCommandBuffer                             commandBuffer,
        VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
        VkPipelineLayout                            layout,
        u32                                         set,
        const void*                                 pData) {
}

@extension("VK_NVX_device_generated_commands") // 87
cmd void vkCmdProcessCommandsNVX(
        VkCommandBuffer                             commandBuffer,
        const VkCmdProcessCommandsInfoNVX*          pProcessCommandsInfo) {
}

@extension("VK_NVX_device_generated_commands") // 87
cmd void vkCmdReserveSpaceForCommandsNVX(
        VkCommandBuffer                             commandBuffer,
        const VkCmdReserveSpaceForCommandsInfoNVX*  pReserveSpaceInfo) {
}

@extension("VK_NVX_device_generated_commands") // 87
cmd VkResult vkCreateIndirectCommandsLayoutNVX(
        VkDevice                                    device,
        const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkIndirectCommandsLayoutNVX*                pIndirectCommandsLayout) {
    return ?
}

@extension("VK_NVX_device_generated_commands") // 87
cmd void vkDestroyIndirectCommandsLayoutNVX(
        VkDevice                                    device,
        VkIndirectCommandsLayoutNVX                 indirectCommandsLayout,
        const VkAllocationCallbacks*                pAllocator) {
}

@extension("VK_NVX_device_generated_commands") // 87
cmd VkResult vkCreateObjectTableNVX(
        VkDevice                                    device,
        const VkObjectTableCreateInfoNVX*           pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkObjectTableNVX*                           pObjectTable) {
    return ?
}

@extension("VK_NVX_device_generated_commands") // 87
cmd void vkDestroyObjectTableNVX(
        VkDevice                                    device,
        VkObjectTableNVX                            objectTable,
        const VkAllocationCallbacks*                pAllocator) {
}

@extension("VK_NVX_device_generated_commands") // 87
cmd VkResult vkRegisterObjectsNVX(
        VkDevice                                    device,
        VkObjectTableNVX                            objectTable,
        u32                                         objectCount,
        const VkObjectTableEntryNVX* const*         ppObjectTableEntries,
        const u32*                                  pObjectIndices) {
    return ?
}

@extension("VK_NVX_device_generated_commands") // 87
cmd VkResult vkUnregisterObjectsNVX(
        VkDevice                                    device,
        VkObjectTableNVX                            objectTable,
        u32                                         objectCount,
        const VkObjectEntryTypeNVX*                 pObjectEntryTypes,
        const u32*                                  pObjectIndices) {
    return ?
}

@extension("VK_NVX_device_generated_commands") // 87
cmd void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
        VkPhysicalDevice                            physicalDevice,
        VkDeviceGeneratedCommandsFeaturesNVX*       pFeatures,
        VkDeviceGeneratedCommandsLimitsNVX*         pLimits) {
}

@extension("VK_NV_clip_space_w_scaling") // 88
cmd void vkCmdSetViewportWScalingNV(
        VkCommandBuffer                             commandBuffer,
        u32                                         firstViewport,
        u32                                         viewportCount,
        const VkViewportWScalingNV*                 pViewportWScalings) {
}

@extension("VK_EXT_direct_mode_display") // 89
cmd VkResult vkReleaseDisplayEXT(
        VkPhysicalDevice                            physicalDevice,
        VkDisplayKHR                                display) {
    return ?
}

@extension("VK_EXT_acquire_xlib_display") // 90
cmd VkResult vkAcquireXlibDisplayEXT(
        VkPhysicalDevice                            physicalDevice,
        platform.Display*                           dpy,
        VkDisplayKHR                                display) {
    return ?
}

@extension("VK_EXT_acquire_xlib_display") // 90
cmd VkResult vkGetRandROutputDisplayEXT(
        VkPhysicalDevice                            physicalDevice,
        platform.Display*                           dpy,
        platform.RROutput                           rrOutput,
        VkDisplayKHR*                               pDisplay) {
    return ?
}

@extension("VK_EXT_display_surface_counter") // 91
cmd VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(
        VkPhysicalDevice                            physicalDevice,
        VkSurfaceKHR                                surface,
        VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities) {
    return ?
}

@extension("VK_EXT_display_control") // 92
cmd VkResult vkDisplayPowerControlEXT(
        VkDevice                                    device,
        VkDisplayKHR                                display,
        const VkDisplayPowerInfoEXT*                pDisplayPowerInfo) {
    return ?
}

@extension("VK_EXT_display_control") // 92
cmd VkResult vkRegisterDeviceEventEXT(
        VkDevice                                    device,
        const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkFence*                                    pFence) {
    return ?
}

@extension("VK_EXT_display_control") // 92
cmd VkResult vkRegisterDisplayEventEXT(
        VkDevice                                    device,
        VkDisplayKHR                                display,
        const VkDisplayEventInfoEXT*                pDisplayEventInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkFence*                                    pFence) {
    return ?
}

@extension("VK_EXT_display_control") // 92
cmd VkResult vkGetSwapchainCounterEXT(
        VkDevice                                    device,
        VkSwapchainKHR                              swapchain,
        VkSurfaceCounterFlagBitsEXT                 counter,
        u64*                                        pCounterValue) {
    return ?
}

@extension("VK_GOOGLE_display_timing") // 93
cmd VkResult vkGetRefreshCycleDurationGOOGLE(
        VkDevice                                    device,
        VkSwapchainKHR                              swapchain,
        VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties) {
    deviceObject := GetDevice(device)
    swapchainObject := GetSwapchain(swapchain)

    displayTimingProperties := ?
    pDisplayTimingProperties[0] = displayTimingProperties

    return ?
}

@extension("VK_GOOGLE_display_timing") // 93
cmd VkResult vkGetPastPresentationTimingGOOGLE(
        VkDevice                                    device,
        VkSwapchainKHR                              swapchain,
        u32*                                        pPresentationTimingCount,
        VkPastPresentationTimingGOOGLE*             pPresentationTimings) {
    return ?
}

@extension("VK_EXT_discard_rectangles") // 100
cmd void vkCmdSetDiscardRectangleEXT(
        VkCommandBuffer                             commandBuffer,
        u32                                         firstDiscardRectangle,
        u32                                         discardRectangleCount,
        const VkRect2D*                             pDiscardRectangles) {
}

@extension("VK_EXT_hdr_metadata") // 106
cmd void vkSetHdrMetadataEXT(
        VkDevice                                    device,
        u32                                         swapchainCount,
        const VkSwapchainKHR*                       pSwapchains,
        const VkHdrMetadataEXT*                     pMetadata) {
}

@extension("VK_KHR_create_renderpass2") // 110
cmd VkResult vkCreateRenderPass2KHR(
        VkDevice                                    device,
        const VkRenderPassCreateInfo2KHR*           pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkRenderPass*                               pRenderPass) {
    return ?
}

@extension("VK_KHR_create_renderpass2") // 110
cmd void vkCmdBeginRenderPass2KHR(
        VkCommandBuffer                             commandBuffer,
        const VkRenderPassBeginInfo*                pRenderPassBegin,
        const VkSubpassBeginInfoKHR*                pSubpassBeginInfo) {
}

@extension("VK_KHR_create_renderpass2") // 110
cmd void vkCmdNextSubpass2KHR(
        VkCommandBuffer                             commandBuffer,
        const VkSubpassBeginInfoKHR*                pSubpassBeginInfo,
        const VkSubpassEndInfoKHR*                  pSubpassEndInfo) {
}

@extension("VK_KHR_create_renderpass2") // 110
cmd void vkCmdEndRenderPass2KHR(
        VkCommandBuffer                             commandBuffer,
        const VkSubpassEndInfoKHR*                  pSubpassEndInfo) {
}

@extension("VK_KHR_shared_presentable_image") // 112
cmd VkResult vkGetSwapchainStatusKHR(
        VkDevice                                    device,
        VkSwapchainKHR                              swapchain) {
    return ?
}

@extension("VK_KHR_external_fence_capabilities") // 113
cmd void vkGetPhysicalDeviceExternalFencePropertiesKHR(
        VkPhysicalDevice                            physicalDevice,
        const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo,
        VkExternalFencePropertiesKHR*               pExternalFenceProperties) {
}

@extension("VK_KHR_external_fence_win32") // 115
cmd VkResult vkImportFenceWin32HandleKHR(
        VkDevice                                    device,
        const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo) {
    return ?
}

@extension("VK_KHR_external_fence_win32") // 115
cmd VkResult vkGetFenceWin32HandleKHR(
        VkDevice                                    device,
        const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
        platform.HANDLE*                            pHandle) {
    return ?
}

@extension("VK_KHR_external_fence_fd") // 116
cmd VkResult vkImportFenceFdKHR(
        VkDevice                                    device,
        const VkImportFenceFdInfoKHR*               pImportFenceFdInfo) {
    return ?
}

@extension("VK_KHR_external_fence_fd") // 116
cmd VkResult vkGetFenceFdKHR(
        VkDevice                                    device,
        const VkFenceGetFdInfoKHR*                  pGetFdInfo,
        int*                                        pFd) {
    return ?
}

@extension("VK_KHR_get_surface_capabilities2") // 120
cmd VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(
        VkPhysicalDevice                            physicalDevice,
        const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
        VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities) {
    return ?
}

@extension("VK_KHR_get_surface_capabilities2") // 120
cmd VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(
        VkPhysicalDevice                            physicalDevice,
        const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
        u32*                                        pSurfaceFormatCount,
        VkSurfaceFormat2KHR*                        pSurfaceFormats) {
    return ?
}

@extension("VK_KHR_display_properties2") // 122
cmd VkResult vkGetPhysicalDeviceDisplayProperties2KHR(
        VkPhysicalDevice                            physicalDevice,
        u32*                                        pPropertyCount,
        VkDisplayProperties2KHR*                    pProperties) {
    return ?
}

@extension("VK_KHR_display_properties2") // 122
cmd VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
        VkPhysicalDevice                            physicalDevice,
        u32*                                        pPropertyCount,
        VkDisplayPlaneProperties2KHR*               pProperties) {
    return ?
}

@extension("VK_KHR_display_properties2") // 122
cmd VkResult vkGetDisplayModeProperties2KHR(
        VkPhysicalDevice                            physicalDevice,
        VkDisplayKHR                                display,
        u32*                                        pPropertyCount,
        VkDisplayModeProperties2KHR*                pProperties) {
    return ?
}

@extension("VK_KHR_display_properties2") // 122
cmd VkResult vkGetDisplayPlaneCapabilities2KHR(
        VkPhysicalDevice                            physicalDevice,
        const VkDisplayPlaneInfo2KHR*               pDisplayPlaneInfo,
        VkDisplayPlaneCapabilities2KHR*             pCapabilities) {
    return ?
}

@extension("VK_MVK_ios_surface") // 123
cmd VkResult vkCreateIOSSurfaceMVK(
        VkInstance                                  instance,
        const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkSurfaceKHR*                               pSurface) {
    return ?
}

@extension("VK_MVK_macos_surface") // 124
cmd VkResult vkCreateMacOSSurfaceMVK(
        VkInstance                                  instance,
        const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkSurfaceKHR*                               pSurface) {
    return ?
}

@extension("VK_EXT_debug_utils") // 129
@external type void* PFN_vkDebugUtilsMessengerCallbackEXT
@extension("VK_EXT_debug_utils") // 129
@pfn cmd VkBool32 vkDebugUtilsMessengerCallbackEXT(
        VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
        VkDebugUtilsMessageTypeFlagsEXT             messageType,
        const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
        void*                                       pUserData) {
    return ?
}

@extension("VK_EXT_debug_utils") // 129
cmd VkResult vkSetDebugUtilsObjectNameEXT(
        VkDevice                                    device,
        const VkDebugUtilsObjectNameInfoEXT*        pNameInfo) {
    return ?
}

@extension("VK_EXT_debug_utils") // 129
cmd VkResult vkSetDebugUtilsObjectTagEXT(
        VkDevice                                    device,
        const VkDebugUtilsObjectTagInfoEXT*         pTagInfo) {
    return ?
}

@extension("VK_EXT_debug_utils") // 129
cmd void vkQueueBeginDebugUtilsLabelEXT(
        VkQueue                                     queue,
        const VkDebugUtilsLabelEXT*                 pLabelInfo) {
}

@extension("VK_EXT_debug_utils") // 129
cmd void vkQueueEndDebugUtilsLabelEXT(VkQueue       queue) {
}

@extension("VK_EXT_debug_utils") // 129
cmd void vkQueueInsertDebugUtilsLabelEXT(
        VkQueue                                     queue,
        const VkDebugUtilsLabelEXT*                 pLabelInfo) {
}

@extension("VK_EXT_debug_utils") // 129
cmd void vkCmdBeginDebugUtilsLabelEXT(
        VkCommandBuffer                             commandBuffer,
        const VkDebugUtilsLabelEXT*                 pLabelInfo) {
}

@extension("VK_EXT_debug_utils") // 129
cmd void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) {
}

@extension("VK_EXT_debug_utils") // 129
cmd void vkCmdInsertDebugUtilsLabelEXT(
        VkCommandBuffer                             commandBuffer,
        const VkDebugUtilsLabelEXT*                 pLabelInfo) {
}

@extension("VK_EXT_debug_utils") // 129
cmd VkResult vkCreateDebugUtilsMessengerEXT(
        VkInstance                                  instance,
        const VkDebugUtilsMessengerCreateInfoEXT*   pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkDebugUtilsMessengerEXT*                   pMessenger) {
    return ?
}

@extension("VK_EXT_debug_utils") // 129
cmd void vkDestroyDebugUtilsMessengerEXT(
        VkInstance                                  instance,
        VkDebugUtilsMessengerEXT                    messenger,
        const VkAllocationCallbacks*                pAllocator) {
}

@extension("VK_EXT_debug_utils") // 129
cmd void vkSubmitDebugUtilsMessageEXT(
        VkInstance                                  instance,
        VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
        VkDebugUtilsMessageTypeFlagsEXT             messageTypes,
        const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {
}

@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
@vulkan1_1 // extension requires 1.1, and should become non-optional when 1.1 does
cmd VkResult vkGetAndroidHardwareBufferPropertiesANDROID(
        VkDevice                                    device,
        const platform.AHardwareBuffer*             buffer,
        VkAndroidHardwareBufferPropertiesANDROID*   pProperties) {
    return ?
}

@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
@vulkan1_1 // extension requires 1.1, and should become non-optional when 1.1 does
cmd VkResult vkGetMemoryAndroidHardwareBufferANDROID(
        VkDevice                                            device,
        const VkMemoryGetAndroidHardwareBufferInfoANDROID*  pInfo,
        platform.AHardwareBuffer**                          pBuffer) {
    return ?
}

@extension("VK_EXT_sample_locations") // 144
cmd void vkCmdSetSampleLocationsEXT(
        VkCommandBuffer                             commandBuffer,
        const VkSampleLocationsInfoEXT*             pSampleLocationsInfo) {
}

@extension("VK_EXT_sample_locations") // 144
cmd void vkGetPhysicalDeviceMultisamplePropertiesEXT(
        VkPhysicalDevice                            physicalDevice,
        VkSampleCountFlagBits                       samples,
        VkMultisamplePropertiesEXT*                 pMultisampleProperties) {
}

@extension("VK_KHR_get_memory_requirements2") // 147
cmd void vkGetImageMemoryRequirements2KHR(
        VkDevice                                    device,
        const VkImageMemoryRequirementsInfo2KHR*    pInfo,
        VkMemoryRequirements2KHR*                   pMemoryRequirements) {
}

@extension("VK_KHR_get_memory_requirements2") // 147
cmd void vkGetBufferMemoryRequirements2KHR(
        VkDevice                                    device,
        const VkBufferMemoryRequirementsInfo2KHR*   pInfo,
        VkMemoryRequirements2KHR*                   pMemoryRequirements) {
}

@extension("VK_KHR_get_memory_requirements2") // 147
cmd void vkGetImageSparseMemoryRequirements2KHR(
        VkDevice                                        device,
        const VkImageSparseMemoryRequirementsInfo2KHR*  pInfo,
        u32*                                            pSparseMemoryRequirementCount,
        VkSparseImageMemoryRequirements2KHR*            pSparseMemoryRequirements) {
}

@extension("VK_KHR_sampler_ycbcr_conversion") // 157
cmd VkResult vkCreateSamplerYcbcrConversionKHR(
        VkDevice                                        device,
        const VkSamplerYcbcrConversionCreateInfoKHR*    pCreateInfo,
        const VkAllocationCallbacks*                    pAllocator,
        VkSamplerYcbcrConversionKHR*                    pYcbcrConversion) {
    return ?
}

@extension("VK_KHR_sampler_ycbcr_conversion") // 157
cmd void vkDestroySamplerYcbcrConversionKHR(
        VkDevice                                        device,
        VkSamplerYcbcrConversionKHR                     ycbcrConversion,
        const VkAllocationCallbacks*                    pAllocator) {
}

@extension("VK_KHR_bind_memory2") // 158
cmd VkResult vkBindBufferMemory2KHR(
        VkDevice                                        device,
        u32                                             bindInfoCount,
        const VkBindBufferMemoryInfoKHR*                pBindInfos) {
    return ?
}

@extension("VK_KHR_bind_memory2") // 158
cmd VkResult vkBindImageMemory2KHR(
        VkDevice                                        device,
        u32                                             bindInfoCount,
        const VkBindImageMemoryInfoKHR*                 pBindInfos) {
    return ?
}

@extension("VK_EXT_image_drm_format_modifier") // 159
cmd VkResult vkGetImageDrmFormatModifierPropertiesEXT(
        VkDevice                                        device,
        VkImage                                         image,
        VkImageDrmFormatModifierPropertiesEXT*          pProperties) {
    return ?
}

@extension("VK_EXT_validation_cache") // 161
cmd VkResult vkCreateValidationCacheEXT(
        VkDevice                                    device,
        const VkValidationCacheCreateInfoEXT*       pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkValidationCacheEXT*                       pValidationCache) {
    return ?
}

@extension("VK_EXT_validation_cache") // 161
cmd void vkDestroyValidationCacheEXT(
        VkDevice                                    device,
        VkValidationCacheEXT                        validationCache,
        const VkAllocationCallbacks*                pAllocator) {
}

@extension("VK_EXT_validation_cache") // 161
cmd VkResult vkMergeValidationCachesEXT(
        VkDevice                                    device,
        VkValidationCacheEXT                        dstCache,
        u32                                         srcCacheCount,
        const VkValidationCacheEXT*                 pSrcCaches) {
    return ?
}

@extension("VK_EXT_validation_cache") // 161
cmd VkResult vkGetValidationCacheDataEXT(
        VkDevice                                    device,
        VkValidationCacheEXT                        validationCache,
        platform.size_t*                            pDataSize,
        void*                                       pData) {
    return ?
}

@extension("VK_NV_shading_rate_image") // 165
cmd void vkCmdBindShadingRateImageNV(
        VkCommandBuffer                             commandBuffer,
        VkImageView                                 imageView,
        VkImageLayout                               imageLayout) {
}

@extension("VK_NV_shading_rate_image") // 165
cmd void vkCmdSetViewportShadingRatePaletteNV(
        VkCommandBuffer                             commandBuffer,
        u32                                         firstViewport,
        u32                                         viewportCount,
        const VkShadingRatePaletteNV*               pShadingRatePalettes) {
}

@extension("VK_NV_shading_rate_image") // 165
cmd void vkCmdSetCoarseSampleOrderNV(
        VkCommandBuffer                             commandBuffer,
        VkCoarseSampleOrderTypeNV                   sampleOrderType,
        u32                                         customSampleOrderCount,
        const VkCoarseSampleOrderCustomNV*          pCustomSampleOrders) {
}

@extension("VK_NVX_raytracing") // 166
cmd VkResult vkCreateAccelerationStructureNVX(
        VkDevice                                    device,
        const VkAccelerationStructureCreateInfoNVX* pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkAccelerationStructureNVX*                 pAccelerationStructure) {
    return ?
}

@extension("VK_NVX_raytracing") // 166
cmd void vkDestroyAccelerationStructureNVX(
        VkDevice                                    device,
        VkAccelerationStructureNVX                  accelerationStructure,
        const VkAllocationCallbacks*                pAllocator) {
}

@extension("VK_NVX_raytracing") // 166
cmd void vkGetAccelerationStructureMemoryRequirementsNVX(
        VkDevice                                                device,
        const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo,
        VkMemoryRequirements2KHR*                               pMemoryRequirements) {
}

@extension("VK_NVX_raytracing") // 166
cmd void vkGetAccelerationStructureScratchMemoryRequirementsNVX(
        VkDevice                                                device,
        const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo,
        VkMemoryRequirements2KHR*                               pMemoryRequirements) {
}

@extension("VK_NVX_raytracing") // 166
cmd VkResult vkBindAccelerationStructureMemoryNVX(
        VkDevice                                        device,
        u32                                             bindInfoCount,
        const VkBindAccelerationStructureMemoryInfoNVX* pBindInfos) {
    return ?
}

@extension("VK_NVX_raytracing") // 166
cmd void vkCmdBuildAccelerationStructureNVX(
        VkCommandBuffer                             commandBuffer,
        VkAccelerationStructureTypeNVX              type,
        u32                                         instanceCount,
        VkBuffer                                    instanceData,
        VkDeviceSize                                instanceOffset,
        u32                                         geometryCount,
        const VkGeometryNVX*                        pGeometries,
        VkBuildAccelerationStructureFlagsNVX        flags,
        VkBool32                                    update,
        VkAccelerationStructureNVX                  dst,
        VkAccelerationStructureNVX                  src,
        VkBuffer                                    scratch,
        VkDeviceSize                                scratchOffset) {
}

@extension("VK_NVX_raytracing") // 166
cmd void vkCmdCopyAccelerationStructureNVX(
        VkCommandBuffer                             commandBuffer,
        VkAccelerationStructureNVX                  dst,
        VkAccelerationStructureNVX                  src,
        VkCopyAccelerationStructureModeNVX          mode) {
}

@extension("VK_NVX_raytracing") // 166
cmd void vkCmdTraceRaysNVX(
        VkCommandBuffer                             commandBuffer,
        VkBuffer                                    raygenShaderBindingTableBuffer,
        VkDeviceSize                                raygenShaderBindingOffset,
        VkBuffer                                    missShaderBindingTableBuffer,
        VkDeviceSize                                missShaderBindingOffset,
        VkDeviceSize                                missShaderBindingStride,
        VkBuffer                                    hitShaderBindingTableBuffer,
        VkDeviceSize                                hitShaderBindingOffset,
        VkDeviceSize                                hitShaderBindingStride,
        u32                                         width,
        u32                                         height) {
}

@extension("VK_NVX_raytracing") // 166
cmd VkResult vkCreateRaytracingPipelinesNVX(
        VkDevice                                    device,
        VkPipelineCache                             pipelineCache,
        u32                                         createInfoCount,
        const VkRaytracingPipelineCreateInfoNVX*    pCreateInfos,
        const VkAllocationCallbacks*                pAllocator,
        VkPipeline*                                 pPipelines) {
    return ?
}

@extension("VK_NVX_raytracing") // 166
cmd VkResult vkGetRaytracingShaderHandlesNVX(
        VkDevice                                    device,
        VkPipeline                                  pipeline,
        u32                                         firstGroup,
        u32                                         groupCount,
        platform.size_t                             dataSize,
        void*                                       pData) {
    return ?
}

@extension("VK_NVX_raytracing") // 166
cmd VkResult vkGetAccelerationStructureHandleNVX(
        VkDevice                                    device,
        VkAccelerationStructureNVX                  accelerationStructure,
        platform.size_t                             dataSize,
        void*                                       pData) {
    return ?
}

@extension("VK_NVX_raytracing") // 166
cmd void vkCmdWriteAccelerationStructurePropertiesNVX(
        VkCommandBuffer                             commandBuffer,
        VkAccelerationStructureNVX                  accelerationStructure,
        VkQueryType                                 queryType,
        VkQueryPool                                 queryPool,
        u32                                         query) {
}

@extension("VK_NVX_raytracing") // 166
cmd VkResult vkCompileDeferredNVX(
        VkDevice                                    device,
        VkPipeline                                  pipeline,
        u32                                         shader) {
    return ?
}

@extension("VK_KHR_maintenance3") // 169
cmd void vkGetDescriptorSetLayoutSupportKHR(
        VkDevice                                    device,
        const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
        VkDescriptorSetLayoutSupportKHR*            pSupport) {
}

@extension("VK_KHR_draw_indirect_count") // 170
cmd void vkCmdDrawIndirectCountKHR(
        VkCommandBuffer                             commandBuffer,
        VkBuffer                                    buffer,
        VkDeviceSize                                offset,
        VkBuffer                                    countBuffer,
        VkDeviceSize                                countBufferOffset,
        u32                                         maxDrawCount,
        u32                                         stride) {
}

@extension("VK_KHR_draw_indirect_count") // 170
cmd void vkCmdDrawIndexedIndirectCountKHR(
        VkCommandBuffer                             commandBuffer,
        VkBuffer                                    buffer,
        VkDeviceSize                                offset,
        VkBuffer                                    countBuffer,
        VkDeviceSize                                countBufferOffset,
        u32                                         maxDrawCount,
        u32                                         stride) {
}

@extension("VK_EXT_external_memory_host") // 179
cmd VkResult vkGetMemoryHostPointerPropertiesEXT(
        VkDevice                                    device,
        VkExternalMemoryHandleTypeFlagBits          handleType,
        const void*                                 pHostPointer,
        VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties) {
    return ?
}

@extension("VK_AMD_buffer_marker") // 180
cmd void vkCmdWriteBufferMarkerAMD(
        VkCommandBuffer                             commandBuffer,
        VkPipelineStageFlagBits                     pipelineStage,
        VkBuffer                                    dstBuffer,
        VkDeviceSize                                dstOffset,
        u32                                         marker) {
}

@extension("VK_EXT_calibrated_timestamps") // 185
cmd VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
        VkPhysicalDevice                            physicalDevice,
        u32*                                        pTimeDomainCount,
        VkTimeDomainEXT*                            pTimeDomains) {
    return ?
}

@extension("VK_EXT_calibrated_timestamps") // 185
cmd VkResult vkGetCalibratedTimestampsEXT(
        VkDevice                                    device,
        u32                                         timestampCount,
        const VkCalibratedTimestampInfoEXT*         pTimestampInfos,
        u64*                                        pTimestamps,
        u64*                                        pMaxDeviation) {
    return ?
}

@extension("VK_NV_mesh_shader") // 203
cmd void vkCmdDrawMeshTasksNV(
        VkCommandBuffer                             commandBuffer,
        u32                                         taskCount,
        u32                                         firstTask) {
}

@extension("VK_NV_mesh_shader") // 203
cmd void vkCmdDrawMeshTasksIndirectNV(
        VkCommandBuffer                             commandBuffer,
        VkBuffer                                    buffer,
        VkDeviceSize                                offset,
        u32                                         drawCount,
        u32                                         stride) {
}

@extension("VK_NV_mesh_shader") // 203
cmd void vkCmdDrawMeshTasksIndirectCountNV(
        VkCommandBuffer                             commandBuffer,
        VkBuffer                                    buffer,
        VkDeviceSize                                offset,
        VkBuffer                                    countBuffer,
        VkDeviceSize                                countBufferOffset,
        u32                                         maxDrawCount,
        u32                                         stride) {
}

@extension("VK_NV_scissor_exclusive") // 206
cmd void vkCmdSetExclusiveScissorNV(
        VkCommandBuffer                             commandBuffer,
        u32                                         firstExclusiveScissor,
        u32                                         exclusiveScissorCount,
        const VkRect2D*                             pExclusiveScissors) {
}

@extension("VK_NV_device_diagnostic_checkpoints") // 207
cmd void vkCmdSetCheckpointNV(
        VkCommandBuffer                             commandBuffer,
        const void*                                 pCheckpointMarker) {
}

@extension("VK_NV_device_diagnostic_checkpoints") // 207
cmd void vkGetQueueCheckpointDataNV(
        VkQueue                                     queue,
        u32*                                        pCheckpointDataCount,
        VkCheckpointDataNV*                         pCheckpointData) {
}

@extension("VK_FUCHSIA_imagepipe_surface") // 215
cmd VkResult vkCreateImagePipeSurfaceFUCHSIA(
        VkInstance                                  instance,
        const VkImagePipeSurfaceCreateInfoFUCHSIA*  pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkSurfaceKHR*                               pSurface) {
    return ?
}


////////////////
// Validation //
////////////////

extern void validate(string layerName, bool condition, string message)


/////////////////////////////
// Internal State Tracking //
/////////////////////////////

StateObject State

@internal class StateObject {
    // Dispatchable objects.
    map!(VkInstance,       ref!InstanceObject)       Instances
    map!(VkPhysicalDevice, ref!PhysicalDeviceObject) PhysicalDevices
    map!(VkDevice,         ref!DeviceObject)         Devices
    map!(VkQueue,          ref!QueueObject)          Queues
    map!(VkCommandBuffer,  ref!CommandBufferObject)  CommandBuffers

    // Non-dispatchable objects.
    map!(VkDeviceMemory,             ref!DeviceMemoryObject)             DeviceMemories
    map!(VkBuffer,                   ref!BufferObject)                   Buffers
    map!(VkBufferView,               ref!BufferViewObject)               BufferViews
    map!(VkImage,                    ref!ImageObject)                    Images
    map!(VkImageView,                ref!ImageViewObject)                ImageViews
    map!(VkShaderModule,             ref!ShaderModuleObject)             ShaderModules
    map!(VkPipeline,                 ref!PipelineObject)                 Pipelines
    map!(VkPipelineLayout,           ref!PipelineLayoutObject)           PipelineLayouts
    map!(VkSampler,                  ref!SamplerObject)                  Samplers
    map!(VkDescriptorSet,            ref!DescriptorSetObject)            DescriptorSets
    map!(VkDescriptorSetLayout,      ref!DescriptorSetLayoutObject)      DescriptorSetLayouts
    map!(VkDescriptorPool,           ref!DescriptorPoolObject)           DescriptorPools
    map!(VkFence,                    ref!FenceObject)                    Fences
    map!(VkSemaphore,                ref!SemaphoreObject)                Semaphores
    map!(VkEvent,                    ref!EventObject)                    Events
    map!(VkQueryPool,                ref!QueryPoolObject)                QueryPools
    map!(VkFramebuffer,              ref!FramebufferObject)              Framebuffers
    map!(VkRenderPass,               ref!RenderPassObject)               RenderPasses
    map!(VkPipelineCache,            ref!PipelineCacheObject)            PipelineCaches
    map!(VkCommandPool,              ref!CommandPoolObject)              CommandPools
    map!(VkSurfaceKHR,               ref!SurfaceObject)                  Surfaces
    map!(VkSwapchainKHR,             ref!SwapchainObject)                Swapchains
}

@internal class InstanceObject {
}

@internal class PhysicalDeviceObject {
    VkInstance instance
}

@internal class DeviceObject {
    VkPhysicalDevice physicalDevice
}

@internal class QueueObject {
    VkDevice      device
    VkQueueFlags  flags
}

@internal class CommandBufferObject {
    VkDevice                  device
    map!(u64, VkDeviceMemory) boundObjects
    VkQueueFlags              queueFlags
}

@internal class DeviceMemoryObject {
    VkDevice                                device
    VkDeviceSize                            allocationSize
    map!(u64, VkDeviceSize)                 boundObjects
    map!(VkCommandBuffer, VkCommandBuffer)  boundCommandBuffers
}

@internal class BufferObject {
    VkDevice              device
    VkDeviceMemory        memory
    VkDeviceSize          memoryOffset
}

@internal class BufferViewObject {
    VkDevice      device
    VkBuffer      buffer
}

@internal class ImageObject {
    VkDevice              device
    VkDeviceMemory        memory
    VkDeviceSize          memoryOffset
}

@internal class ImageViewObject {
    VkDevice      device
    VkImage       image
}

@internal class ShaderObject {
    VkDevice      device
}

@internal class ShaderModuleObject {
    VkDevice      device
}

@internal class PipelineObject {
    VkDevice      device
}

@internal class PipelineLayoutObject {
    VkDevice      device
}

@internal class SamplerObject {
    VkDevice      device
}

@internal class DescriptorSetObject {
    VkDevice      device
}

@internal class DescriptorSetLayoutObject {
    VkDevice      device
}

@internal class DescriptorPoolObject {
    VkDevice      device
}

@internal class FenceObject {
    VkDevice      device
    bool          signaled
}

@internal class SemaphoreObject {
    VkDevice      device
}

@internal class EventObject {
    VkDevice      device
}

@internal class QueryPoolObject {
    VkDevice      device
}

@internal class FramebufferObject {
    VkDevice      device
}

@internal class RenderPassObject {
    VkDevice      device
}

@internal class PipelineCacheObject {
    VkDevice      device
}

@internal class CommandPoolObject {
    VkDevice      device
}

@internal class SurfaceObject {
    VkInstance    instance
}

@internal class SwapchainObject {
    VkDevice      device
}

macro ref!InstanceObject GetInstance(VkInstance instance) {
    assert(instance in State.Instances)
    return State.Instances[instance]
}

macro ref!PhysicalDeviceObject GetPhysicalDevice(VkPhysicalDevice physicalDevice) {
    assert(physicalDevice in State.PhysicalDevices)
    return State.PhysicalDevices[physicalDevice]
}

macro ref!DeviceObject GetDevice(VkDevice device) {
    assert(device in State.Devices)
    return State.Devices[device]
}

macro ref!QueueObject GetQueue(VkQueue queue) {
    assert(queue in State.Queues)
    return State.Queues[queue]
}

macro ref!CommandBufferObject GetCommandBuffer(VkCommandBuffer commandBuffer) {
    assert(commandBuffer in State.CommandBuffers)
    return State.CommandBuffers[commandBuffer]
}

macro ref!DeviceMemoryObject GetDeviceMemory(VkDeviceMemory memory) {
    assert(memory in State.DeviceMemories)
    return State.DeviceMemories[memory]
}

macro ref!BufferObject GetBuffer(VkBuffer buffer) {
    assert(buffer in State.Buffers)
    return State.Buffers[buffer]
}

macro ref!BufferViewObject GetBufferView(VkBufferView bufferView) {
    assert(bufferView in State.BufferViews)
    return State.BufferViews[bufferView]
}

macro ref!ImageObject GetImage(VkImage image) {
    assert(image in State.Images)
    return State.Images[image]
}

macro ref!ImageViewObject GetImageView(VkImageView imageView) {
    assert(imageView in State.ImageViews)
    return State.ImageViews[imageView]
}

macro ref!ShaderModuleObject GetShaderModule(VkShaderModule shaderModule) {
    assert(shaderModule in State.ShaderModules)
    return State.ShaderModules[shaderModule]
}

macro ref!PipelineObject GetPipeline(VkPipeline pipeline) {
    assert(pipeline in State.Pipelines)
    return State.Pipelines[pipeline]
}

macro ref!PipelineLayoutObject GetPipelineLayout(VkPipelineLayout pipelineLayout) {
    assert(pipelineLayout in State.PipelineLayouts)
    return State.PipelineLayouts[pipelineLayout]
}

macro ref!SamplerObject GetSampler(VkSampler sampler) {
    assert(sampler in State.Samplers)
    return State.Samplers[sampler]
}

macro ref!DescriptorSetObject GetDescriptorSet(VkDescriptorSet descriptorSet) {
    assert(descriptorSet in State.DescriptorSets)
    return State.DescriptorSets[descriptorSet]
}

macro ref!DescriptorSetLayoutObject GetDescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout) {
    assert(descriptorSetLayout in State.DescriptorSetLayouts)
    return State.DescriptorSetLayouts[descriptorSetLayout]
}

macro ref!DescriptorPoolObject GetDescriptorPool(VkDescriptorPool descriptorPool) {
    assert(descriptorPool in State.DescriptorPools)
    return State.DescriptorPools[descriptorPool]
}

macro ref!FenceObject GetFence(VkFence fence) {
    assert(fence in State.Fences)
    return State.Fences[fence]
}

macro ref!SemaphoreObject GetSemaphore(VkSemaphore semaphore) {
    assert(semaphore in State.Semaphores)
    return State.Semaphores[semaphore]
}

macro ref!EventObject GetEvent(VkEvent event) {
    assert(event in State.Events)
    return State.Events[event]
}

macro ref!QueryPoolObject GetQueryPool(VkQueryPool queryPool) {
    assert(queryPool in State.QueryPools)
    return State.QueryPools[queryPool]
}

macro ref!FramebufferObject GetFramebuffer(VkFramebuffer framebuffer) {
    assert(framebuffer in State.Framebuffers)
    return State.Framebuffers[framebuffer]
}

macro ref!RenderPassObject GetRenderPass(VkRenderPass renderPass) {
    assert(renderPass in State.RenderPasses)
    return State.RenderPasses[renderPass]
}

macro ref!PipelineCacheObject GetPipelineCache(VkPipelineCache pipelineCache) {
    assert(pipelineCache in State.PipelineCaches)
    return State.PipelineCaches[pipelineCache]
}

macro ref!CommandPoolObject GetCommandPool(VkCommandPool commandPool) {
    assert(commandPool in State.CommandPools)
    return State.CommandPools[commandPool]
}

macro ref!SurfaceObject GetSurface(VkSurfaceKHR surface) {
    assert(surface in State.Surfaces)
    return State.Surfaces[surface]
}

macro ref!SwapchainObject GetSwapchain(VkSwapchainKHR swapchain) {
    assert(swapchain in State.Swapchains)
    return State.Swapchains[swapchain]
}

macro VkQueueFlags AddQueueFlag(VkQueueFlags flags, VkQueueFlagBits bit) {
    return as!VkQueueFlags(as!u32(flags) | as!u32(bit))
}