# Written by Leonardo Mariscal <leo@ldmd.mx>, 2019

## Vulkan Bindings
## ====
## WARNING: This is a generated file. Do not edit
## Any edits will be overwritten by the generator.

when defined(linux):
  import x11/x
  import x11/xlib
when defined(windows):
  import winim

var vkGetProc: proc(procName: cstring): pointer {.cdecl.}

import dynlib

when defined(windows):
  {. emit: """#define VK_USE_PLATFORM_WIN32_KHR""" .}
  const vkDLL = "vulkan-1.dll"
elif defined(linux):
  {.passl: gorge("pkg-config --libs vulkan").}
  {. emit: """#define VK_USE_PLATFORM_X11_KHR""" .}
  const vkDLL = "libvulkan.so.1"
else:
  raise quit("Unsupported platform")

let vkHandleDLL = loadLib(vkDLL)
if isNil(vkHandleDLL):
  quit("could not load: " & vkDLL)

vkGetProc = proc(procName: cstring): pointer {.cdecl.} =
  result = symAddr(vkHandleDLL, procName)
  if result == nil:
    raiseInvalidLibrary(procName)

proc setVKGetProc*(getProc: proc(procName: cstring): pointer {.cdecl.}) =
  vkGetProc = getProc

type
  VkHandle* = int64
  VkNonDispatchableHandle* = int64
  ANativeWindow = ptr object
  CAMetalLayer = ptr object
  AHardwareBuffer = ptr object
  VkBool32* = distinct uint32

# Enums
const
  VK_MAX_PHYSICAL_DEVICE_NAME_SIZE* = 256
  VK_UUID_SIZE* = 16
  VK_LUID_SIZE* = 8
  VK_LUID_SIZE_KHR* = VK_LUID_SIZE
  VK_MAX_EXTENSION_NAME_SIZE* = 256
  VK_MAX_DESCRIPTION_SIZE* = 256
  VK_MAX_MEMORY_TYPES* = 32
  VK_MAX_MEMORY_HEAPS* = 16
  VK_LOD_CLAMP_NONE* = 1000.0f
  VK_REMAINING_MIP_LEVELS* = (not 0'u32)
  VK_REMAINING_ARRAY_LAYERS* = (not 0'u32)
  VK_WHOLE_SIZE* = (not 0'u64)
  VK_ATTACHMENT_UNUSED* = (not 0'u32)
  VK_TRUE* = VkBool32(1)
  VK_FALSE* = VkBool32(0)
  VK_QUEUE_FAMILY_IGNORED* = (not 0'u32)
  VK_QUEUE_FAMILY_EXTERNAL* = (not 0'u32) - 1
  VK_QUEUE_FAMILY_EXTERNAL_KHR* = VK_QUEUE_FAMILY_EXTERNAL
  VK_QUEUE_FAMILY_FOREIGN_EXT* = (not 0'u32) - 2
  VK_SUBPASS_EXTERNAL* = (not 0'u32)
  VK_MAX_DEVICE_GROUP_SIZE* = 32
  VK_MAX_DEVICE_GROUP_SIZE_KHR* = VK_MAX_DEVICE_GROUP_SIZE
  VK_MAX_DRIVER_NAME_SIZE* = 256
  VK_MAX_DRIVER_NAME_SIZE_KHR* = VK_MAX_DRIVER_NAME_SIZE
  VK_MAX_DRIVER_INFO_SIZE* = 256
  VK_MAX_DRIVER_INFO_SIZE_KHR* = VK_MAX_DRIVER_INFO_SIZE
  VK_SHADER_UNUSED_KHR* = (not 0'u32)
  VK_SHADER_UNUSED_NV* = VK_SHADER_UNUSED_KHR

type
  VkImageLayout* {.size: sizeof(cint).} = enum
    VK_IMAGE_LAYOUT_UNDEFINED = 0
    VK_IMAGE_LAYOUT_GENERAL = 1
    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2
    VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3
    VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4
    VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5
    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6
    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7
    VK_IMAGE_LAYOUT_PREINITIALIZED = 8
    VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
  VkAttachmentLoadOp* {.size: sizeof(cint).} = enum
    VK_ATTACHMENT_LOAD_OP_LOAD = 0
    VK_ATTACHMENT_LOAD_OP_CLEAR = 1
    VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2
  VkAttachmentStoreOp* {.size: sizeof(cint).} = enum
    VK_ATTACHMENT_STORE_OP_STORE = 0
    VK_ATTACHMENT_STORE_OP_DONT_CARE = 1
  VkImageType* {.size: sizeof(cint).} = enum
    VK_IMAGE_TYPE_1D = 0
    VK_IMAGE_TYPE_2D = 1
    VK_IMAGE_TYPE_3D = 2
  VkImageTiling* {.size: sizeof(cint).} = enum
    VK_IMAGE_TILING_OPTIMAL = 0
    VK_IMAGE_TILING_LINEAR = 1
  VkImageViewType* {.size: sizeof(cint).} = enum
    VK_IMAGE_VIEW_TYPE_1D = 0
    VK_IMAGE_VIEW_TYPE_2D = 1
    VK_IMAGE_VIEW_TYPE_3D = 2
    VK_IMAGE_VIEW_TYPE_CUBE = 3
    VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4
    VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5
    VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6
  VkCommandBufferLevel* {.size: sizeof(cint).} = enum
    VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0
    VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1
  VkComponentSwizzle* {.size: sizeof(cint).} = enum
    VK_COMPONENT_SWIZZLE_IDENTITY = 0
    VK_COMPONENT_SWIZZLE_ZERO = 1
    VK_COMPONENT_SWIZZLE_ONE = 2
    VK_COMPONENT_SWIZZLE_R = 3
    VK_COMPONENT_SWIZZLE_G = 4
    VK_COMPONENT_SWIZZLE_B = 5
    VK_COMPONENT_SWIZZLE_A = 6
  VkDescriptorType* {.size: sizeof(cint).} = enum
    VK_DESCRIPTOR_TYPE_SAMPLER = 0
    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1
    VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2
    VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3
    VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4
    VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5
    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6
    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7
    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8
    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9
    VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10
  VkQueryType* {.size: sizeof(cint).} = enum
    VK_QUERY_TYPE_OCCLUSION = 0
    VK_QUERY_TYPE_PIPELINE_STATISTICS = 1
    VK_QUERY_TYPE_TIMESTAMP = 2
  VkBorderColor* {.size: sizeof(cint).} = enum
    VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0
    VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1
    VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2
    VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3
    VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4
    VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5
  VkPipelineBindPoint* {.size: sizeof(cint).} = enum
    VK_PIPELINE_BIND_POINT_GRAPHICS = 0
    VK_PIPELINE_BIND_POINT_COMPUTE = 1
  VkPipelineCacheHeaderVersion* {.size: sizeof(cint).} = enum
    VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1
  VkPrimitiveTopology* {.size: sizeof(cint).} = enum
    VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0
    VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1
    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5
    VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6
    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9
    VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10
  VkSharingMode* {.size: sizeof(cint).} = enum
    VK_SHARING_MODE_EXCLUSIVE = 0
    VK_SHARING_MODE_CONCURRENT = 1
  VkIndexType* {.size: sizeof(cint).} = enum
    VK_INDEX_TYPE_UINT16 = 0
    VK_INDEX_TYPE_UINT32 = 1
  VkFilter* {.size: sizeof(cint).} = enum
    VK_FILTER_NEAREST = 0
    VK_FILTER_LINEAR = 1
  VkSamplerMipmapMode* {.size: sizeof(cint).} = enum
    VK_SAMPLER_MIPMAP_MODE_NEAREST = 0
    VK_SAMPLER_MIPMAP_MODE_LINEAR = 1
  VkSamplerAddressMode* {.size: sizeof(cint).} = enum
    VK_SAMPLER_ADDRESS_MODE_REPEAT = 0
    VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1
    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2
    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3
  VkCompareOp* {.size: sizeof(cint).} = enum
    VK_COMPARE_OP_NEVER = 0
    VK_COMPARE_OP_LESS = 1
    VK_COMPARE_OP_EQUAL = 2
    VK_COMPARE_OP_LESS_OR_EQUAL = 3
    VK_COMPARE_OP_GREATER = 4
    VK_COMPARE_OP_NOT_EQUAL = 5
    VK_COMPARE_OP_GREATER_OR_EQUAL = 6
    VK_COMPARE_OP_ALWAYS = 7
  VkPolygonMode* {.size: sizeof(cint).} = enum
    VK_POLYGON_MODE_FILL = 0
    VK_POLYGON_MODE_LINE = 1
    VK_POLYGON_MODE_POINT = 2
  VkCullModeFlagBits* {.size: sizeof(cint).} = enum
    VK_CULL_MODE_NONE = 0
    VK_CULL_MODE_FRONT_BIT = 1
    VK_CULL_MODE_BACK_BIT = 2
    VK_CULL_MODE_FRONT_AND_BACK = 3
  VkFrontFace* {.size: sizeof(cint).} = enum
    VK_FRONT_FACE_COUNTER_CLOCKWISE = 0
    VK_FRONT_FACE_CLOCKWISE = 1
  VkBlendFactor* {.size: sizeof(cint).} = enum
    VK_BLEND_FACTOR_ZERO = 0
    VK_BLEND_FACTOR_ONE = 1
    VK_BLEND_FACTOR_SRC_COLOR = 2
    VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3
    VK_BLEND_FACTOR_DST_COLOR = 4
    VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5
    VK_BLEND_FACTOR_SRC_ALPHA = 6
    VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7
    VK_BLEND_FACTOR_DST_ALPHA = 8
    VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9
    VK_BLEND_FACTOR_CONSTANT_COLOR = 10
    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11
    VK_BLEND_FACTOR_CONSTANT_ALPHA = 12
    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13
    VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14
    VK_BLEND_FACTOR_SRC1_COLOR = 15
    VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16
    VK_BLEND_FACTOR_SRC1_ALPHA = 17
    VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18
  VkBlendOp* {.size: sizeof(cint).} = enum
    VK_BLEND_OP_ADD = 0
    VK_BLEND_OP_SUBTRACT = 1
    VK_BLEND_OP_REVERSE_SUBTRACT = 2
    VK_BLEND_OP_MIN = 3
    VK_BLEND_OP_MAX = 4
  VkStencilOp* {.size: sizeof(cint).} = enum
    VK_STENCIL_OP_KEEP = 0
    VK_STENCIL_OP_ZERO = 1
    VK_STENCIL_OP_REPLACE = 2
    VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3
    VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4
    VK_STENCIL_OP_INVERT = 5
    VK_STENCIL_OP_INCREMENT_AND_WRAP = 6
    VK_STENCIL_OP_DECREMENT_AND_WRAP = 7
  VkLogicOp* {.size: sizeof(cint).} = enum
    VK_LOGIC_OP_CLEAR = 0
    VK_LOGIC_OP_AND = 1
    VK_LOGIC_OP_AND_REVERSE = 2
    VK_LOGIC_OP_COPY = 3
    VK_LOGIC_OP_AND_INVERTED = 4
    VK_LOGIC_OP_NO_OP = 5
    VK_LOGIC_OP_XOR = 6
    VK_LOGIC_OP_OR = 7
    VK_LOGIC_OP_NOR = 8
    VK_LOGIC_OP_EQUIVALENT = 9
    VK_LOGIC_OP_INVERT = 10
    VK_LOGIC_OP_OR_REVERSE = 11
    VK_LOGIC_OP_COPY_INVERTED = 12
    VK_LOGIC_OP_OR_INVERTED = 13
    VK_LOGIC_OP_NAND = 14
    VK_LOGIC_OP_SET = 15
  VkInternalAllocationType* {.size: sizeof(cint).} = enum
    VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0
  VkSystemAllocationScope* {.size: sizeof(cint).} = enum
    VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0
    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1
    VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2
    VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3
    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4
  VkPhysicalDeviceType* {.size: sizeof(cint).} = enum
    VK_PHYSICAL_DEVICE_TYPE_OTHER = 0
    VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1
    VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2
    VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3
    VK_PHYSICAL_DEVICE_TYPE_CPU = 4
  VkVertexInputRate* {.size: sizeof(cint).} = enum
    VK_VERTEX_INPUT_RATE_VERTEX = 0
    VK_VERTEX_INPUT_RATE_INSTANCE = 1
  VkFormat* {.size: sizeof(cint).} = enum
    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
  VkStructureType* {.size: sizeof(cint).} = enum
    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
    VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000 # added by sam
    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001 # added by sam
    VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000 # added by sam
    VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000 # added by sam
    VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004 # added by sam
  VkSubpassContents* {.size: sizeof(cint).} = enum
    VK_SUBPASS_CONTENTS_INLINE = 0
    VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1
  VkResult* {.size: sizeof(cint).} = enum
    VK_ERROR_OUT_OF_DATE_KHR = -1000001004 # added by sam
    VK_ERROR_UNKNOWN = -13
    VK_ERROR_FRAGMENTED_POOL = -12
    VK_ERROR_FORMAT_NOT_SUPPORTED = -11
    VK_ERROR_TOO_MANY_OBJECTS = -10
    VK_ERROR_INCOMPATIBLE_DRIVER = -9
    VK_ERROR_FEATURE_NOT_PRESENT = -8
    VK_ERROR_EXTENSION_NOT_PRESENT = -7
    VK_ERROR_LAYER_NOT_PRESENT = -6
    VK_ERROR_MEMORY_MAP_FAILED = -5
    VK_ERROR_DEVICE_LOST = -4
    VK_ERROR_INITIALIZATION_FAILED = -3
    VK_ERROR_OUT_OF_DEVICE_MEMORY = -2
    VK_ERROR_OUT_OF_HOST_MEMORY = -1
    VK_SUCCESS = 0
    VK_NOT_READY = 1
    VK_TIMEOUT = 2
    VK_EVENT_SET = 3
    VK_EVENT_RESET = 4
    VK_INCOMPLETE = 5
    VK_SUBOPTIMAL_KHR = 1000001003, # added by sam
  VkDynamicState* {.size: sizeof(cint).} = enum
    VK_DYNAMIC_STATE_VIEWPORT = 0
    VK_DYNAMIC_STATE_SCISSOR = 1
    VK_DYNAMIC_STATE_LINE_WIDTH = 2
    VK_DYNAMIC_STATE_DEPTH_BIAS = 3
    VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4
    VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5
    VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6
    VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7
    VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8
  VkDescriptorUpdateTemplateType* {.size: sizeof(cint).} = enum
    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0
  VkObjectType* {.size: sizeof(cint).} = enum
    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
  VkQueueFlagBits* {.size: sizeof(cint).} = enum
    VK_QUEUE_GRAPHICS_BIT = 1
    VK_QUEUE_COMPUTE_BIT = 2
    VK_QUEUE_TRANSFER_BIT = 4
    VK_QUEUE_SPARSE_BINDING_BIT = 8
  VkMemoryPropertyFlagBits* {.size: sizeof(cint).} = enum
    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 1
    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 2
    VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 4
    VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 8
    VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 16
  VkMemoryHeapFlagBits* {.size: sizeof(cint).} = enum
    VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1
  VkAccessFlagBits* {.size: sizeof(cint).} = enum
    VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 1
    VK_ACCESS_INDEX_READ_BIT = 2
    VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 4
    VK_ACCESS_UNIFORM_READ_BIT = 8
    VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 16
    VK_ACCESS_SHADER_READ_BIT = 32
    VK_ACCESS_SHADER_WRITE_BIT = 64
    VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 128
    VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 256
    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 512
    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 1024
    VK_ACCESS_TRANSFER_READ_BIT = 2048
    VK_ACCESS_TRANSFER_WRITE_BIT = 4096
    VK_ACCESS_HOST_READ_BIT = 8192
    VK_ACCESS_HOST_WRITE_BIT = 16384
    VK_ACCESS_MEMORY_READ_BIT = 32768
    VK_ACCESS_MEMORY_WRITE_BIT = 65536
  VkBufferUsageFlagBits* {.size: sizeof(cint).} = enum
    VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 1
    VK_BUFFER_USAGE_TRANSFER_DST_BIT = 2
    VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 4
    VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 8
    VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 16
    VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 32
    VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 64
    VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 128
    VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 256
  VkBufferCreateFlagBits* {.size: sizeof(cint).} = enum
    VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 1
    VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 2
    VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 4
  VkShaderStageFlagBits* {.size: sizeof(cint).} = enum
    VK_SHADER_STAGE_VERTEX_BIT = 1
    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 2
    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 4
    VK_SHADER_STAGE_GEOMETRY_BIT = 8
    VK_SHADER_STAGE_FRAGMENT_BIT = 16
    VK_SHADER_STAGE_ALL_GRAPHICS = 31
    VK_SHADER_STAGE_COMPUTE_BIT = 32
    VK_SHADER_STAGE_ALL = 2147483647
  VkImageUsageFlagBits* {.size: sizeof(cint).} = enum
    VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 1
    VK_IMAGE_USAGE_TRANSFER_DST_BIT = 2
    VK_IMAGE_USAGE_SAMPLED_BIT = 4
    VK_IMAGE_USAGE_STORAGE_BIT = 8
    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 16
    VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 32
    VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 64
    VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 128
  VkImageCreateFlagBits* {.size: sizeof(cint).} = enum
    VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 1
    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 2
    VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 4
    VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 8
    VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 16
  VkPipelineCreateFlagBits* {.size: sizeof(cint).} = enum
    VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 1
    VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 2
    VK_PIPELINE_CREATE_DERIVATIVE_BIT = 4
  VkColorComponentFlagBits* {.size: sizeof(cint).} = enum
    VK_COLOR_COMPONENT_R_BIT = 1
    VK_COLOR_COMPONENT_G_BIT = 2
    VK_COLOR_COMPONENT_B_BIT = 4
    VK_COLOR_COMPONENT_A_BIT = 8
  VkFenceCreateFlagBits* {.size: sizeof(cint).} = enum
    VK_FENCE_CREATE_SIGNALED_BIT = 1
  VkFormatFeatureFlagBits* {.size: sizeof(cint).} = enum
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 1
    VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 2
    VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 4
    VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 8
    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 16
    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 32
    VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 64
    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 128
    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 256
    VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 512
    VK_FORMAT_FEATURE_BLIT_SRC_BIT = 1024
    VK_FORMAT_FEATURE_BLIT_DST_BIT = 2048
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 4096
  VkQueryControlFlagBits* {.size: sizeof(cint).} = enum
    VK_QUERY_CONTROL_PRECISE_BIT = 1
  VkQueryResultFlagBits* {.size: sizeof(cint).} = enum
    VK_QUERY_RESULT_64_BIT = 1
    VK_QUERY_RESULT_WAIT_BIT = 2
    VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 4
    VK_QUERY_RESULT_PARTIAL_BIT = 8
  VkCommandBufferUsageFlagBits* {.size: sizeof(cint).} = enum
    VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 1
    VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 2
    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 4
  VkQueryPipelineStatisticFlagBits* {.size: sizeof(cint).} = enum
    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 1
    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 2
    VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 4
    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 8
    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 16
    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 32
    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 64
    VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 128
    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 256
    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 512
    VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 1024
  VkImageAspectFlagBits* {.size: sizeof(cint).} = enum
    VK_IMAGE_ASPECT_COLOR_BIT = 1
    VK_IMAGE_ASPECT_DEPTH_BIT = 2
    VK_IMAGE_ASPECT_STENCIL_BIT = 4
    VK_IMAGE_ASPECT_METADATA_BIT = 8
  VkSparseImageFormatFlagBits* {.size: sizeof(cint).} = enum
    VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 1
    VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 2
    VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 4
  VkSparseMemoryBindFlagBits* {.size: sizeof(cint).} = enum
    VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1
  VkPipelineStageFlagBits* {.size: sizeof(cint).} = enum
    VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 1
    VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 2
    VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 4
    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 8
    VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 16
    VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 32
    VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 64
    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 128
    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 256
    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 512
    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 1024
    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 2048
    VK_PIPELINE_STAGE_TRANSFER_BIT = 4096
    VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 8192
    VK_PIPELINE_STAGE_HOST_BIT = 16384
    VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 32768
    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 65536
  VkCommandPoolCreateFlagBits* {.size: sizeof(cint).} = enum
    VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1
    VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2
  VkCommandPoolResetFlagBits* {.size: sizeof(cint).} = enum
    VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1
  VkCommandBufferResetFlagBits* {.size: sizeof(cint).} = enum
    VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1
  VkSampleCountFlagBits* {.size: sizeof(cint).} = enum
    VK_SAMPLE_COUNT_1_BIT = 1
    VK_SAMPLE_COUNT_2_BIT = 2
    VK_SAMPLE_COUNT_4_BIT = 4
    VK_SAMPLE_COUNT_8_BIT = 8
    VK_SAMPLE_COUNT_16_BIT = 16
    VK_SAMPLE_COUNT_32_BIT = 32
    VK_SAMPLE_COUNT_64_BIT = 64
  VkAttachmentDescriptionFlagBits* {.size: sizeof(cint).} = enum
    VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1
  VkStencilFaceFlagBits* {.size: sizeof(cint).} = enum
    VK_STENCIL_FACE_FRONT_BIT = 1
    VK_STENCIL_FACE_BACK_BIT = 2
    VK_STENCIL_FACE_FRONT_AND_BACK = 3
  VkDescriptorPoolCreateFlagBits* {.size: sizeof(cint).} = enum
    VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1
  VkDependencyFlagBits* {.size: sizeof(cint).} = enum
    VK_DEPENDENCY_BY_REGION_BIT = 1
  VkSemaphoreType* {.size: sizeof(cint).} = enum
    VK_SEMAPHORE_TYPE_BINARY = 0
    VK_SEMAPHORE_TYPE_TIMELINE = 1
  VkSemaphoreWaitFlagBits* {.size: sizeof(cint).} = enum
    VK_SEMAPHORE_WAIT_ANY_BIT = 1
  VkPresentModeKHR* {.size: sizeof(cint).} = enum
    VK_PRESENT_MODE_IMMEDIATE_KHR = 0
    VK_PRESENT_MODE_MAILBOX_KHR = 1
    VK_PRESENT_MODE_FIFO_KHR = 2
    VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3
  VkColorSpaceKHR* {.size: sizeof(cint).} = enum
    VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0
  VkDisplayPlaneAlphaFlagBitsKHR* {.size: sizeof(cint).} = enum
    VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 1
    VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 2
    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 4
    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 8
  VkCompositeAlphaFlagBitsKHR* {.size: sizeof(cint).} = enum
    VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 1
    VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 2
    VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 4
    VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 8
  VkSurfaceTransformFlagBitsKHR* {.size: sizeof(cint).} = enum
    VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 1
    VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 2
    VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 4
    VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 8
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 16
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 32
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 64
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 128
    VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 256
  VkSwapchainImageUsageFlagBitsANDROID* {.size: sizeof(cint).} = enum
    VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID = 1
  VkTimeDomainEXT* {.size: sizeof(cint).} = enum
    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
  VkDebugReportFlagBitsEXT* {.size: sizeof(cint).} = enum
    VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 1
    VK_DEBUG_REPORT_WARNING_BIT_EXT = 2
    VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 4
    VK_DEBUG_REPORT_ERROR_BIT_EXT = 8
    VK_DEBUG_REPORT_DEBUG_BIT_EXT = 16
  VkDebugReportObjectTypeEXT* {.size: sizeof(cint).} = enum
    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_VALIDATION_CACHE_EXT_EXT = 33
  VkRasterizationOrderAMD* {.size: sizeof(cint).} = enum
    VK_RASTERIZATION_ORDER_STRICT_AMD = 0
    VK_RASTERIZATION_ORDER_RELAXED_AMD = 1
  VkExternalMemoryHandleTypeFlagBitsNV* {.size: sizeof(cint).} = enum
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 1
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 2
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 4
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 8
  VkExternalMemoryFeatureFlagBitsNV* {.size: sizeof(cint).} = enum
    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 1
    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 2
    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 4
  VkValidationCheckEXT* {.size: sizeof(cint).} = enum
    VK_VALIDATION_CHECK_ALL_EXT = 0
    VK_VALIDATION_CHECK_SHADERS_EXT = 1
  VkValidationFeatureEnableEXT* {.size: sizeof(cint).} = enum
    VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0
    VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1
    VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2
    VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3
    VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4
  VkValidationFeatureDisableEXT* {.size: sizeof(cint).} = enum
    VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0
    VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1
    VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2
    VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3
    VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4
    VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5
    VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6
  VkSubgroupFeatureFlagBits* {.size: sizeof(cint).} = enum
    VK_SUBGROUP_FEATURE_BASIC_BIT = 1
    VK_SUBGROUP_FEATURE_VOTE_BIT = 2
    VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 4
    VK_SUBGROUP_FEATURE_BALLOT_BIT = 8
    VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 16
    VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 32
    VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 64
    VK_SUBGROUP_FEATURE_QUAD_BIT = 128
  VkIndirectCommandsLayoutUsageFlagBitsNV* {.size: sizeof(cint).} = enum
    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 1
    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 2
    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 4
  VkIndirectStateFlagBitsNV* {.size: sizeof(cint).} = enum
    VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 1
  VkIndirectCommandsTokenTypeNV* {.size: sizeof(cint).} = enum
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7
  VkExternalMemoryHandleTypeFlagBits* {.size: sizeof(cint).} = enum
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 1
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 4
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 8
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 16
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 32
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 64
  VkExternalMemoryFeatureFlagBits* {.size: sizeof(cint).} = enum
    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 1
    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 2
    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 4
  VkExternalSemaphoreHandleTypeFlagBits* {.size: sizeof(cint).} = enum
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 1
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 4
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 8
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 16
  VkExternalSemaphoreFeatureFlagBits* {.size: sizeof(cint).} = enum
    VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 1
    VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 2
  VkSemaphoreImportFlagBits* {.size: sizeof(cint).} = enum
    VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 1
  VkExternalFenceHandleTypeFlagBits* {.size: sizeof(cint).} = enum
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 1
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 4
    VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 8
  VkExternalFenceFeatureFlagBits* {.size: sizeof(cint).} = enum
    VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 1
    VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 2
  VkFenceImportFlagBits* {.size: sizeof(cint).} = enum
    VK_FENCE_IMPORT_TEMPORARY_BIT = 1
  VkSurfaceCounterFlagBitsEXT* {.size: sizeof(cint).} = enum
    VK_SURFACE_COUNTER_VBLANK_EXT = 1
  VkDisplayPowerStateEXT* {.size: sizeof(cint).} = enum
    VK_DISPLAY_POWER_STATE_OFF_EXT = 0
    VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1
    VK_DISPLAY_POWER_STATE_ON_EXT = 2
  VkDeviceEventTypeEXT* {.size: sizeof(cint).} = enum
    VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0
  VkDisplayEventTypeEXT* {.size: sizeof(cint).} = enum
    VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0
  VkPeerMemoryFeatureFlagBits* {.size: sizeof(cint).} = enum
    VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 1
    VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 2
    VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 4
    VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 8
  VkMemoryAllocateFlagBits* {.size: sizeof(cint).} = enum
    VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 1
  VkDeviceGroupPresentModeFlagBitsKHR* {.size: sizeof(cint).} = enum
    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 1
    VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 2
    VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 4
    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 8
  VkViewportCoordinateSwizzleNV* {.size: sizeof(cint).} = enum
    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
  VkDiscardRectangleModeEXT* {.size: sizeof(cint).} = enum
    VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0
    VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1
  VkPointClippingBehavior* {.size: sizeof(cint).} = enum
    VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0
    VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1
  VkSamplerReductionMode* {.size: sizeof(cint).} = enum
    VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0
    VK_SAMPLER_REDUCTION_MODE_MIN = 1
    VK_SAMPLER_REDUCTION_MODE_MAX = 2
  VkTessellationDomainOrigin* {.size: sizeof(cint).} = enum
    VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0
    VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1
  VkSamplerYcbcrModelConversion* {.size: sizeof(cint).} = enum
    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
  VkSamplerYcbcrRange* {.size: sizeof(cint).} = enum
    VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0
    VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1
  VkChromaLocation* {.size: sizeof(cint).} = enum
    VK_CHROMA_LOCATION_COSITED_EVEN = 0
    VK_CHROMA_LOCATION_MIDPOINT = 1
  VkBlendOverlapEXT* {.size: sizeof(cint).} = enum
    VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0
    VK_BLEND_OVERLAP_DISJOINT_EXT = 1
    VK_BLEND_OVERLAP_CONJOINT_EXT = 2
  VkCoverageModulationModeNV* {.size: sizeof(cint).} = enum
    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
  VkCoverageReductionModeNV* {.size: sizeof(cint).} = enum
    VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0
    VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1
  VkValidationCacheHeaderVersionEXT* {.size: sizeof(cint).} = enum
    VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1
  VkShaderInfoTypeAMD* {.size: sizeof(cint).} = enum
    VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0
    VK_SHADER_INFO_TYPE_BINARY_AMD = 1
    VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2
  VkQueueGlobalPriorityEXT* {.size: sizeof(cint).} = enum
    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
  VkDebugUtilsMessageSeverityFlagBitsEXT* {.size: sizeof(cint).} = enum
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 1
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 16
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 256
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 4096
  VkDebugUtilsMessageTypeFlagBitsEXT* {.size: sizeof(cint).} = enum
    VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 1
    VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 2
    VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 4
  VkConservativeRasterizationModeEXT* {.size: sizeof(cint).} = enum
    VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0
    VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1
    VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2
  VkDescriptorBindingFlagBits* {.size: sizeof(cint).} = enum
    VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 1
    VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 2
    VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 4
    VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 8
  VkVendorId* {.size: sizeof(cint).} = enum
    VK_VENDOR_ID_VIV = 65537
    VK_VENDOR_ID_VSI = 65538
    VK_VENDOR_ID_KAZAN = 65539
    VK_VENDOR_ID_CODEPLAY = 65540
    VK_VENDOR_ID_MESA = 65541
  VkDriverId* {.size: sizeof(cint).} = enum
    VK_DRIVER_ID_AMD_PROPRIETARY = 1
    VK_DRIVER_ID_AMD_OPEN_SOURCE = 2
    VK_DRIVER_ID_MESA_RADV = 3
    VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4
    VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5
    VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6
    VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7
    VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8
    VK_DRIVER_ID_ARM_PROPRIETARY = 9
    VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10
    VK_DRIVER_ID_GGP_PROPRIETARY = 11
    VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12
    VK_DRIVER_ID_MESA_LLVMPIPE = 13
    VK_DRIVER_ID_MOLTENVK = 14
  VkConditionalRenderingFlagBitsEXT* {.size: sizeof(cint).} = enum
    VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 1
  VkResolveModeFlagBits* {.size: sizeof(cint).} = enum
    VK_RESOLVE_MODE_NONE = 0
    VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 1
    VK_RESOLVE_MODE_AVERAGE_BIT = 2
    VK_RESOLVE_MODE_MIN_BIT = 4
    VK_RESOLVE_MODE_MAX_BIT = 8
  VkShadingRatePaletteEntryNV* {.size: sizeof(cint).} = enum
    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
  VkCoarseSampleOrderTypeNV* {.size: sizeof(cint).} = enum
    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
  VkGeometryInstanceFlagBitsKHR* {.size: sizeof(cint).} = enum
    VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 1
    VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = 2
    VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 4
    VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 8
  VkGeometryFlagBitsKHR* {.size: sizeof(cint).} = enum
    VK_GEOMETRY_OPAQUE_BIT_KHR = 1
    VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 2
  VkBuildAccelerationStructureFlagBitsKHR* {.size: sizeof(cint).} = enum
    VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 1
    VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 2
    VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 4
    VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 8
    VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 16
  VkCopyAccelerationStructureModeKHR* {.size: sizeof(cint).} = enum
    VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0
    VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1
    VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2
    VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3
  VkAccelerationStructureTypeKHR* {.size: sizeof(cint).} = enum
    VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0
    VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1
  VkGeometryTypeKHR* {.size: sizeof(cint).} = enum
    VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0
    VK_GEOMETRY_TYPE_AABBS_KHR = 1
  VkAccelerationStructureMemoryRequirementsTypeKHR* {.size: sizeof(cint).} = enum
    VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_KHR = 0
    VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_KHR = 1
    VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_KHR = 2
  VkAccelerationStructureBuildTypeKHR* {.size: sizeof(cint).} = enum
    VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0
    VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1
    VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2
  VkRayTracingShaderGroupTypeKHR* {.size: sizeof(cint).} = enum
    VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0
    VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1
    VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2
  VkMemoryOverallocationBehaviorAMD* {.size: sizeof(cint).} = enum
    VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0
    VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1
    VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2
  VkScopeNV* {.size: sizeof(cint).} = enum
    VK_SCOPE_DEVICE_NV = 1
    VK_SCOPE_WORKGROUP_NV = 2
    VK_SCOPE_SUBGROUP_NV = 3
    VK_SCOPE_QUEUE_FAMILY_NV = 5
  VkComponentTypeNV* {.size: sizeof(cint).} = enum
    VK_COMPONENT_TYPE_FLOAT16_NV = 0
    VK_COMPONENT_TYPE_FLOAT32_NV = 1
    VK_COMPONENT_TYPE_FLOAT64_NV = 2
    VK_COMPONENT_TYPE_SINT8_NV = 3
    VK_COMPONENT_TYPE_SINT16_NV = 4
    VK_COMPONENT_TYPE_SINT32_NV = 5
    VK_COMPONENT_TYPE_SINT64_NV = 6
    VK_COMPONENT_TYPE_UINT8_NV = 7
    VK_COMPONENT_TYPE_UINT16_NV = 8
    VK_COMPONENT_TYPE_UINT32_NV = 9
    VK_COMPONENT_TYPE_UINT64_NV = 10
  VkDeviceDiagnosticsConfigFlagBitsNV* {.size: sizeof(cint).} = enum
    VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 1
    VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 2
    VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 4
  VkPipelineCreationFeedbackFlagBitsEXT* {.size: sizeof(cint).} = enum
    VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = 1
    VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = 2
    VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = 4
  VkFullScreenExclusiveEXT* {.size: sizeof(cint).} = enum
    VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0
    VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1
    VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2
    VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3
  VkPerformanceCounterScopeKHR* {.size: sizeof(cint).} = enum
    VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0
    VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1
    VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2
  VkPerformanceCounterUnitKHR* {.size: sizeof(cint).} = enum
    VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0
    VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1
    VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2
    VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3
    VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4
    VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5
    VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6
    VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7
    VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8
    VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9
    VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10
  VkPerformanceCounterStorageKHR* {.size: sizeof(cint).} = enum
    VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0
    VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1
    VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2
    VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3
    VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4
    VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5
  VkPerformanceCounterDescriptionFlagBitsKHR* {.size: sizeof(cint).} = enum
    VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = 1
    VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = 2
  VkPerformanceConfigurationTypeINTEL* {.size: sizeof(cint).} = enum
    VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0
  VkQueryPoolSamplingModeINTEL* {.size: sizeof(cint).} = enum
    VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0
  VkPerformanceOverrideTypeINTEL* {.size: sizeof(cint).} = enum
    VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0
    VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1
  VkPerformanceParameterTypeINTEL* {.size: sizeof(cint).} = enum
    VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0
    VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1
  VkPerformanceValueTypeINTEL* {.size: sizeof(cint).} = enum
    VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0
    VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1
    VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2
    VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3
    VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4
  VkShaderFloatControlsIndependence* {.size: sizeof(cint).} = enum
    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0
    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1
    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2
  VkPipelineExecutableStatisticFormatKHR* {.size: sizeof(cint).} = enum
    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0
    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1
    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2
    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3
  VkLineRasterizationModeEXT* {.size: sizeof(cint).} = enum
    VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0
    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1
    VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2
    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3
  VkToolPurposeFlagBitsEXT* {.size: sizeof(cint).} = enum
    VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = 1
    VK_TOOL_PURPOSE_PROFILING_BIT_EXT = 2
    VK_TOOL_PURPOSE_TRACING_BIT_EXT = 4
    VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = 8
    VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = 16

# Types

# stub types if we are on the wrong platform, so we don't need to "when" all platform functions
when not defined(linux):
  type
    Display* = ptr object
    VisualID* = ptr object
    Window* = ptr object
when not defined(windows):
  type
    HINSTANCE* = ptr object
    HWND* = ptr object
    HMONITOR* = ptr object
    HANDLE* = ptr object
    SECURITY_ATTRIBUTES* = ptr object
    DWORD* = ptr object
    LPCWSTR* = ptr object

type
  RROutput* = ptr object
  wl_display* = ptr object
  wl_surface* = ptr object
  xcb_connection_t* = ptr object
  xcb_visualid_t* = ptr object
  xcb_window_t* = ptr object
  IDirectFB* = ptr object
  IDirectFBSurface* = ptr object
  zx_handle_t* = ptr object
  GgpStreamDescriptor* = ptr object
  GgpFrameToken* = ptr object

template vkMakeVersion*(major, minor, patch: untyped): untyped =
  (((major) shl 22) or ((minor) shl 12) or (patch))

template vkVersionMajor*(version: untyped): untyped =
  ((uint32)(version) shr 22)

template vkVersionMinor*(version: untyped): untyped =
  (((uint32)(version) shr 12) and 0x000003FF)

template vkVersionPatch*(version: untyped): untyped =
  ((uint32)(version) and 0x00000FFF)

const vkApiVersion1_0* = vkMakeVersion(1, 0, 0)
const vkApiVersion1_1* = vkMakeVersion(1, 1, 0)
const vkApiVersion1_2* = vkMakeVersion(1, 2, 0)

type
  VkSampleMask* = distinct uint32
  VkFlags* = distinct uint32
  VkDeviceSize* = distinct uint64
  VkDeviceAddress* = distinct uint64
  VkFramebufferCreateFlags* = distinct VkFlags
  VkQueryPoolCreateFlags* = distinct VkFlags
  VkRenderPassCreateFlags* = distinct VkFlags
  VkSamplerCreateFlags* = distinct VkFlags
  VkPipelineLayoutCreateFlags* = distinct VkFlags
  VkPipelineCacheCreateFlags* = distinct VkFlags
  VkPipelineDepthStencilStateCreateFlags* = distinct VkFlags
  VkPipelineDynamicStateCreateFlags* = distinct VkFlags
  VkPipelineColorBlendStateCreateFlags* = distinct VkFlags
  VkPipelineMultisampleStateCreateFlags* = distinct VkFlags
  VkPipelineRasterizationStateCreateFlags* = distinct VkFlags
  VkPipelineViewportStateCreateFlags* = distinct VkFlags
  VkPipelineTessellationStateCreateFlags* = distinct VkFlags
  VkPipelineInputAssemblyStateCreateFlags* = distinct VkFlags
  VkPipelineVertexInputStateCreateFlags* = distinct VkFlags
  VkPipelineShaderStageCreateFlags* = distinct VkFlags
  VkDescriptorSetLayoutCreateFlags* = distinct VkFlags
  VkBufferViewCreateFlags* = distinct VkFlags
  VkInstanceCreateFlags* = distinct VkFlags
  VkDeviceCreateFlags* = distinct VkFlags
  VkDeviceQueueCreateFlags* = distinct VkFlags
  VkQueueFlags* = distinct VkFlags
  VkMemoryPropertyFlags* = distinct VkFlags
  VkMemoryHeapFlags* = distinct VkFlags
  VkAccessFlags* = distinct VkFlags
  VkBufferUsageFlags* = distinct VkFlags
  VkBufferCreateFlags* = distinct VkFlags
  VkShaderStageFlags* = distinct VkFlags
  VkImageUsageFlags* = distinct VkFlags
  VkImageCreateFlags* = distinct VkFlags
  VkImageViewCreateFlags* = distinct VkFlags
  VkPipelineCreateFlags* = distinct VkFlags
  VkColorComponentFlags* = distinct VkFlags
  VkFenceCreateFlags* = distinct VkFlags
  VkSemaphoreCreateFlags* = distinct VkFlags
  VkFormatFeatureFlags* = distinct VkFlags
  VkQueryControlFlags* = distinct VkFlags
  VkQueryResultFlags* = distinct VkFlags
  VkShaderModuleCreateFlags* = distinct VkFlags
  VkEventCreateFlags* = distinct VkFlags
  VkCommandPoolCreateFlags* = distinct VkFlags
  VkCommandPoolResetFlags* = distinct VkFlags
  VkCommandBufferResetFlags* = distinct VkFlags
  VkCommandBufferUsageFlags* = distinct VkFlags
  VkQueryPipelineStatisticFlags* = distinct VkFlags
  VkMemoryMapFlags* = distinct VkFlags
  VkImageAspectFlags* = distinct VkFlags
  VkSparseMemoryBindFlags* = distinct VkFlags
  VkSparseImageFormatFlags* = distinct VkFlags
  VkSubpassDescriptionFlags* = distinct VkFlags
  VkPipelineStageFlags* = distinct VkFlags
  VkSampleCountFlags* = distinct VkFlags
  VkAttachmentDescriptionFlags* = distinct VkFlags
  VkStencilFaceFlags* = distinct VkFlags
  VkCullModeFlags* = distinct VkFlags
  VkDescriptorPoolCreateFlags* = distinct VkFlags
  VkDescriptorPoolResetFlags* = distinct VkFlags
  VkDependencyFlags* = distinct VkFlags
  VkSubgroupFeatureFlags* = distinct VkFlags
  VkIndirectCommandsLayoutUsageFlagsNV* = distinct VkFlags
  VkIndirectStateFlagsNV* = distinct VkFlags
  VkGeometryFlagsKHR* = distinct VkFlags
  VkGeometryFlagsNV* = VkGeometryFlagsKHR
  VkGeometryInstanceFlagsKHR* = distinct VkFlags
  VkGeometryInstanceFlagsNV* = VkGeometryInstanceFlagsKHR
  VkBuildAccelerationStructureFlagsKHR* = distinct VkFlags
  VkBuildAccelerationStructureFlagsNV* = VkBuildAccelerationStructureFlagsKHR
  VkPrivateDataSlotCreateFlagsEXT* = distinct VkFlags
  VkDescriptorUpdateTemplateCreateFlags* = distinct VkFlags
  VkDescriptorUpdateTemplateCreateFlagsKHR* = VkDescriptorUpdateTemplateCreateFlags
  VkPipelineCreationFeedbackFlagsEXT* = distinct VkFlags
  VkPerformanceCounterDescriptionFlagsKHR* = distinct VkFlags
  VkAcquireProfilingLockFlagsKHR* = distinct VkFlags
  VkSemaphoreWaitFlags* = distinct VkFlags
  VkSemaphoreWaitFlagsKHR* = VkSemaphoreWaitFlags
  VkPipelineCompilerControlFlagsAMD* = distinct VkFlags
  VkShaderCorePropertiesFlagsAMD* = distinct VkFlags
  VkDeviceDiagnosticsConfigFlagsNV* = distinct VkFlags
  VkCompositeAlphaFlagsKHR* = distinct VkFlags
  VkDisplayPlaneAlphaFlagsKHR* = distinct VkFlags
  VkSurfaceTransformFlagsKHR* = distinct VkFlags
  VkSwapchainCreateFlagsKHR* = distinct VkFlags
  VkDisplayModeCreateFlagsKHR* = distinct VkFlags
  VkDisplaySurfaceCreateFlagsKHR* = distinct VkFlags
  VkAndroidSurfaceCreateFlagsKHR* = distinct VkFlags
  VkViSurfaceCreateFlagsNN* = distinct VkFlags
  VkWaylandSurfaceCreateFlagsKHR* = distinct VkFlags
  VkWin32SurfaceCreateFlagsKHR* = distinct VkFlags
  VkXlibSurfaceCreateFlagsKHR* = distinct VkFlags
  VkXcbSurfaceCreateFlagsKHR* = distinct VkFlags
  VkDirectFBSurfaceCreateFlagsEXT* = distinct VkFlags
  VkIOSSurfaceCreateFlagsMVK* = distinct VkFlags
  VkMacOSSurfaceCreateFlagsMVK* = distinct VkFlags
  VkMetalSurfaceCreateFlagsEXT* = distinct VkFlags
  VkImagePipeSurfaceCreateFlagsFUCHSIA* = distinct VkFlags
  VkStreamDescriptorSurfaceCreateFlagsGGP* = distinct VkFlags
  VkHeadlessSurfaceCreateFlagsEXT* = distinct VkFlags
  VkPeerMemoryFeatureFlags* = distinct VkFlags
  VkPeerMemoryFeatureFlagsKHR* = VkPeerMemoryFeatureFlags
  VkMemoryAllocateFlags* = distinct VkFlags
  VkMemoryAllocateFlagsKHR* = VkMemoryAllocateFlags
  VkDeviceGroupPresentModeFlagsKHR* = distinct VkFlags
  VkDebugReportFlagsEXT* = distinct VkFlags
  VkCommandPoolTrimFlags* = distinct VkFlags
  VkCommandPoolTrimFlagsKHR* = VkCommandPoolTrimFlags
  VkExternalMemoryHandleTypeFlagsNV* = distinct VkFlags
  VkExternalMemoryFeatureFlagsNV* = distinct VkFlags
  VkExternalMemoryHandleTypeFlags* = distinct VkFlags
  VkExternalMemoryHandleTypeFlagsKHR* = VkExternalMemoryHandleTypeFlags
  VkExternalMemoryFeatureFlags* = distinct VkFlags
  VkExternalMemoryFeatureFlagsKHR* = VkExternalMemoryFeatureFlags
  VkExternalSemaphoreHandleTypeFlags* = distinct VkFlags
  VkExternalSemaphoreHandleTypeFlagsKHR* = VkExternalSemaphoreHandleTypeFlags
  VkExternalSemaphoreFeatureFlags* = distinct VkFlags
  VkExternalSemaphoreFeatureFlagsKHR* = VkExternalSemaphoreFeatureFlags
  VkSemaphoreImportFlags* = distinct VkFlags
  VkSemaphoreImportFlagsKHR* = VkSemaphoreImportFlags
  VkExternalFenceHandleTypeFlags* = distinct VkFlags
  VkExternalFenceHandleTypeFlagsKHR* = VkExternalFenceHandleTypeFlags
  VkExternalFenceFeatureFlags* = distinct VkFlags
  VkExternalFenceFeatureFlagsKHR* = VkExternalFenceFeatureFlags
  VkFenceImportFlags* = distinct VkFlags
  VkFenceImportFlagsKHR* = VkFenceImportFlags
  VkSurfaceCounterFlagsEXT* = distinct VkFlags
  VkPipelineViewportSwizzleStateCreateFlagsNV* = distinct VkFlags
  VkPipelineDiscardRectangleStateCreateFlagsEXT* = distinct VkFlags
  VkPipelineCoverageToColorStateCreateFlagsNV* = distinct VkFlags
  VkPipelineCoverageModulationStateCreateFlagsNV* = distinct VkFlags
  VkPipelineCoverageReductionStateCreateFlagsNV* = distinct VkFlags
  VkValidationCacheCreateFlagsEXT* = distinct VkFlags
  VkDebugUtilsMessageSeverityFlagsEXT* = distinct VkFlags
  VkDebugUtilsMessageTypeFlagsEXT* = distinct VkFlags
  VkDebugUtilsMessengerCreateFlagsEXT* = distinct VkFlags
  VkDebugUtilsMessengerCallbackDataFlagsEXT* = distinct VkFlags
  VkPipelineRasterizationConservativeStateCreateFlagsEXT* = distinct VkFlags
  VkDescriptorBindingFlags* = distinct VkFlags
  VkDescriptorBindingFlagsEXT* = VkDescriptorBindingFlags
  VkConditionalRenderingFlagsEXT* = distinct VkFlags
  VkResolveModeFlags* = distinct VkFlags
  VkResolveModeFlagsKHR* = VkResolveModeFlags
  VkPipelineRasterizationStateStreamCreateFlagsEXT* = distinct VkFlags
  VkPipelineRasterizationDepthClipStateCreateFlagsEXT* = distinct VkFlags
  VkSwapchainImageUsageFlagsANDROID* = distinct VkFlags
  VkToolPurposeFlagsEXT* = distinct VkFlags
  VkInstance* = distinct VkHandle
  VkPhysicalDevice* = distinct VkHandle
  VkDevice* = distinct VkHandle
  VkQueue* = distinct VkHandle
  VkCommandBuffer* = distinct VkHandle
  VkDeviceMemory* = distinct VkNonDispatchableHandle
  VkCommandPool* = distinct VkNonDispatchableHandle
  VkBuffer* = distinct VkNonDispatchableHandle
  VkBufferView* = distinct VkNonDispatchableHandle
  VkImage* = distinct VkNonDispatchableHandle
  VkImageView* = distinct VkNonDispatchableHandle
  VkShaderModule* = distinct VkNonDispatchableHandle
  VkPipeline* = distinct VkNonDispatchableHandle
  VkPipelineLayout* = distinct VkNonDispatchableHandle
  VkSampler* = distinct VkNonDispatchableHandle
  VkDescriptorSet* = distinct VkNonDispatchableHandle
  VkDescriptorSetLayout* = distinct VkNonDispatchableHandle
  VkDescriptorPool* = distinct VkNonDispatchableHandle
  VkFence* = distinct VkNonDispatchableHandle
  VkSemaphore* = distinct VkNonDispatchableHandle
  VkEvent* = distinct VkNonDispatchableHandle
  VkQueryPool* = distinct VkNonDispatchableHandle
  VkFramebuffer* = distinct VkNonDispatchableHandle
  VkRenderPass* = distinct VkNonDispatchableHandle
  VkPipelineCache* = distinct VkNonDispatchableHandle
  VkIndirectCommandsLayoutNV* = distinct VkNonDispatchableHandle
  VkDescriptorUpdateTemplate* = distinct VkNonDispatchableHandle
  VkDescriptorUpdateTemplateKHR* = VkDescriptorUpdateTemplate
  VkSamplerYcbcrConversion* = distinct VkNonDispatchableHandle
  VkSamplerYcbcrConversionKHR* = VkSamplerYcbcrConversion
  VkValidationCacheEXT* = distinct VkNonDispatchableHandle
  VkAccelerationStructureKHR* = distinct VkNonDispatchableHandle
  VkAccelerationStructureNV* = VkAccelerationStructureKHR
  VkPerformanceConfigurationINTEL* = distinct VkNonDispatchableHandle
  VkDeferredOperationKHR* = distinct VkNonDispatchableHandle
  VkPrivateDataSlotEXT* = distinct VkNonDispatchableHandle
  VkDisplayKHR* = distinct VkNonDispatchableHandle
  VkDisplayModeKHR* = distinct VkNonDispatchableHandle
  VkSurfaceKHR* = distinct VkNonDispatchableHandle
  VkSwapchainKHR* = distinct VkNonDispatchableHandle
  VkDebugReportCallbackEXT* = distinct VkNonDispatchableHandle
  VkDebugUtilsMessengerEXT* = distinct VkNonDispatchableHandle
  VkDescriptorUpdateTemplateTypeKHR* = VkDescriptorUpdateTemplateType
  VkPointClippingBehaviorKHR* = VkPointClippingBehavior
  VkResolveModeFlagBitsKHR* = VkResolveModeFlagBits
  VkDescriptorBindingFlagBitsEXT* = VkDescriptorBindingFlagBits
  VkSemaphoreTypeKHR* = VkSemaphoreType
  VkGeometryFlagBitsNV* = VkGeometryFlagBitsKHR
  VkGeometryInstanceFlagBitsNV* = VkGeometryInstanceFlagBitsKHR
  VkBuildAccelerationStructureFlagBitsNV* = VkBuildAccelerationStructureFlagBitsKHR
  VkCopyAccelerationStructureModeNV* = VkCopyAccelerationStructureModeKHR
  VkAccelerationStructureTypeNV* = VkAccelerationStructureTypeKHR
  VkGeometryTypeNV* = VkGeometryTypeKHR
  VkRayTracingShaderGroupTypeNV* = VkRayTracingShaderGroupTypeKHR
  VkAccelerationStructureMemoryRequirementsTypeNV* = VkAccelerationStructureMemoryRequirementsTypeKHR
  VkSemaphoreWaitFlagBitsKHR* = VkSemaphoreWaitFlagBits
  VkExternalMemoryHandleTypeFlagBitsKHR* = VkExternalMemoryHandleTypeFlagBits
  VkExternalMemoryFeatureFlagBitsKHR* = VkExternalMemoryFeatureFlagBits
  VkExternalSemaphoreHandleTypeFlagBitsKHR* = VkExternalSemaphoreHandleTypeFlagBits
  VkExternalSemaphoreFeatureFlagBitsKHR* = VkExternalSemaphoreFeatureFlagBits
  VkSemaphoreImportFlagBitsKHR* = VkSemaphoreImportFlagBits
  VkExternalFenceHandleTypeFlagBitsKHR* = VkExternalFenceHandleTypeFlagBits
  VkExternalFenceFeatureFlagBitsKHR* = VkExternalFenceFeatureFlagBits
  VkFenceImportFlagBitsKHR* = VkFenceImportFlagBits
  VkPeerMemoryFeatureFlagBitsKHR* = VkPeerMemoryFeatureFlagBits
  VkMemoryAllocateFlagBitsKHR* = VkMemoryAllocateFlagBits
  VkTessellationDomainOriginKHR* = VkTessellationDomainOrigin
  VkSamplerYcbcrModelConversionKHR* = VkSamplerYcbcrModelConversion
  VkSamplerYcbcrRangeKHR* = VkSamplerYcbcrRange
  VkChromaLocationKHR* = VkChromaLocation
  VkSamplerReductionModeEXT* = VkSamplerReductionMode
  VkShaderFloatControlsIndependenceKHR* = VkShaderFloatControlsIndependence
  VkDriverIdKHR* = VkDriverId
  PFN_vkInternalAllocationNotification* = proc(pUserData: pointer; size: csize_t; allocationType: VkInternalAllocationType; allocationScope: VkSystemAllocationScope) {.cdecl.}
  PFN_vkInternalFreeNotification* = proc(pUserData: pointer; size: csize_t; allocationType: VkInternalAllocationType; allocationScope: VkSystemAllocationScope) {.cdecl.}
  PFN_vkReallocationFunction* = proc(pUserData: pointer; pOriginal: pointer; size: csize_t; alignment: csize_t; allocationScope: VkSystemAllocationScope): pointer {.cdecl.}
  PFN_vkAllocationFunction* = proc(pUserData: pointer; size: csize_t; alignment: csize_t; allocationScope: VkSystemAllocationScope): pointer {.cdecl.}
  PFN_vkFreeFunction* = proc(pUserData: pointer; pMemory: pointer) {.cdecl.}
  PFN_vkVoidFunction* = proc() {.cdecl.}
  PFN_vkDebugReportCallbackEXT* = proc(flags: VkDebugReportFlagsEXT; objectType: VkDebugReportObjectTypeEXT; cbObject: uint64; location: csize_t; messageCode:  int32; pLayerPrefix: cstring; pMessage: cstring; pUserData: pointer): VkBool32 {.cdecl.}
  PFN_vkDebugUtilsMessengerCallbackEXT* = proc(messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: VkDebugUtilsMessengerCallbackDataEXT, userData: pointer): VkBool32 {.cdecl.}

  VkOffset2D* = object
    x*: int32
    y*: int32

  VkOffset3D* = object
    x*: int32
    y*: int32
    z*: int32

  VkExtent2D* = object
    width*: uint32
    height*: uint32

  VkExtent3D* = object
    width*: uint32
    height*: uint32
    depth*: uint32

  VkViewport* = object
    x*: float32
    y*: float32
    width*: float32
    height*: float32
    minDepth*: float32
    maxDepth*: float32

  VkRect2D* = object
    offset*: VkOffset2D
    extent*: VkExtent2D

  VkClearRect* = object
    rect*: VkRect2D
    baseArrayLayer*: uint32
    layerCount*: uint32

  VkComponentMapping* = object
    r*: VkComponentSwizzle
    g*: VkComponentSwizzle
    b*: VkComponentSwizzle
    a*: VkComponentSwizzle

  VkPhysicalDeviceProperties* = object
    apiVersion*: uint32
    driverVersion*: uint32
    vendorID*: uint32
    deviceID*: uint32
    deviceType*: VkPhysicalDeviceType
    deviceName*: array[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, char]
    pipelineCacheUUID*: array[VK_UUID_SIZE, uint8]
    limits*: VkPhysicalDeviceLimits
    sparseProperties*: VkPhysicalDeviceSparseProperties

  VkExtensionProperties* = object
    extensionName*: array[VK_MAX_EXTENSION_NAME_SIZE, char]
    specVersion*: uint32

  VkLayerProperties* = object
    layerName*: array[VK_MAX_EXTENSION_NAME_SIZE, char]
    specVersion*: uint32
    implementationVersion*: uint32
    description*: array[VK_MAX_DESCRIPTION_SIZE, char]

  VkApplicationInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    pApplicationName*: cstring
    applicationVersion*: uint32
    pEngineName*: cstring
    engineVersion*: uint32
    apiVersion*: uint32

  VkAllocationCallbacks* = object
    pUserData*: pointer
    pfnAllocation*: PFN_vkAllocationFunction
    pfnReallocation*: PFN_vkReallocationFunction
    pfnFree*: PFN_vkFreeFunction
    pfnInternalAllocation*: PFN_vkInternalAllocationNotification
    pfnInternalFree*: PFN_vkInternalFreeNotification

  VkDeviceQueueCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDeviceQueueCreateFlags
    queueFamilyIndex*: uint32
    queueCount*: uint32
    pQueuePriorities*: ptr float32

  VkDeviceCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDeviceCreateFlags
    queueCreateInfoCount*: uint32
    pQueueCreateInfos*: ptr VkDeviceQueueCreateInfo
    enabledLayerCount*: uint32
    ppEnabledLayerNames*: cstringArray
    enabledExtensionCount*: uint32
    ppEnabledExtensionNames*: cstringArray
    pEnabledFeatures*: ptr VkPhysicalDeviceFeatures

  VkInstanceCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkInstanceCreateFlags
    pApplicationInfo*: ptr VkApplicationInfo
    enabledLayerCount*: uint32
    ppEnabledLayerNames*: cstringArray
    enabledExtensionCount*: uint32
    ppEnabledExtensionNames*: cstringArray

  VkQueueFamilyProperties* = object
    queueFlags*: VkQueueFlags
    queueCount*: uint32
    timestampValidBits*: uint32
    minImageTransferGranularity*: VkExtent3D

  VkPhysicalDeviceMemoryProperties* = object
    memoryTypeCount*: uint32
    memoryTypes*: array[VK_MAX_MEMORY_TYPES, VkMemoryType]
    memoryHeapCount*: uint32
    memoryHeaps*: array[VK_MAX_MEMORY_HEAPS, VkMemoryHeap]

  VkMemoryAllocateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    allocationSize*: VkDeviceSize
    memoryTypeIndex*: uint32

  VkMemoryRequirements* = object
    size*: VkDeviceSize
    alignment*: VkDeviceSize
    memoryTypeBits*: uint32

  VkSparseImageFormatProperties* = object
    aspectMask*: VkImageAspectFlags
    imageGranularity*: VkExtent3D
    flags*: VkSparseImageFormatFlags

  VkSparseImageMemoryRequirements* = object
    formatProperties*: VkSparseImageFormatProperties
    imageMipTailFirstLod*: uint32
    imageMipTailSize*: VkDeviceSize
    imageMipTailOffset*: VkDeviceSize
    imageMipTailStride*: VkDeviceSize

  VkMemoryType* = object
    propertyFlags*: VkMemoryPropertyFlags
    heapIndex*: uint32

  VkMemoryHeap* = object
    size*: VkDeviceSize
    flags*: VkMemoryHeapFlags

  VkMappedMemoryRange* = object
    sType*: VkStructureType
    pNext*: pointer
    memory*: VkDeviceMemory
    offset*: VkDeviceSize
    size*: VkDeviceSize

  VkFormatProperties* = object
    linearTilingFeatures*: VkFormatFeatureFlags
    optimalTilingFeatures*: VkFormatFeatureFlags
    bufferFeatures*: VkFormatFeatureFlags

  VkImageFormatProperties* = object
    maxExtent*: VkExtent3D
    maxMipLevels*: uint32
    maxArrayLayers*: uint32
    sampleCounts*: VkSampleCountFlags
    maxResourceSize*: VkDeviceSize

  VkDescriptorBufferInfo* = object
    buffer*: VkBuffer
    offset*: VkDeviceSize
    range*: VkDeviceSize

  VkDescriptorImageInfo* = object
    sampler*: VkSampler
    imageView*: VkImageView
    imageLayout*: VkImageLayout

  VkWriteDescriptorSet* = object
    sType*: VkStructureType
    pNext*: pointer
    dstSet*: VkDescriptorSet
    dstBinding*: uint32
    dstArrayElement*: uint32
    descriptorCount*: uint32
    descriptorType*: VkDescriptorType
    pImageInfo*: ptr VkDescriptorImageInfo
    pBufferInfo*: ptr ptr VkDescriptorBufferInfo
    pTexelBufferView*: ptr VkBufferView

  VkCopyDescriptorSet* = object
    sType*: VkStructureType
    pNext*: pointer
    srcSet*: VkDescriptorSet
    srcBinding*: uint32
    srcArrayElement*: uint32
    dstSet*: VkDescriptorSet
    dstBinding*: uint32
    dstArrayElement*: uint32
    descriptorCount*: uint32

  VkBufferCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkBufferCreateFlags
    size*: VkDeviceSize
    usage*: VkBufferUsageFlags
    sharingMode*: VkSharingMode
    queueFamilyIndexCount*: uint32
    pQueueFamilyIndices*: ptr uint32

  VkBufferViewCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkBufferViewCreateFlags
    buffer*: VkBuffer
    format*: VkFormat
    offset*: VkDeviceSize
    range*: VkDeviceSize

  VkImageSubresource* = object
    aspectMask*: VkImageAspectFlags
    mipLevel*: uint32
    arrayLayer*: uint32

  VkImageSubresourceLayers* = object
    aspectMask*: VkImageAspectFlags
    mipLevel*: uint32
    baseArrayLayer*: uint32
    layerCount*: uint32

  VkImageSubresourceRange* = object
    aspectMask*: VkImageAspectFlags
    baseMipLevel*: uint32
    levelCount*: uint32
    baseArrayLayer*: uint32
    layerCount*: uint32

  VkMemoryBarrier* = object
    sType*: VkStructureType
    pNext*: pointer
    srcAccessMask*: VkAccessFlags
    dstAccessMask*: VkAccessFlags

  VkBufferMemoryBarrier* = object
    sType*: VkStructureType
    pNext*: pointer
    srcAccessMask*: VkAccessFlags
    dstAccessMask*: VkAccessFlags
    srcQueueFamilyIndex*: uint32
    dstQueueFamilyIndex*: uint32
    buffer*: VkBuffer
    offset*: VkDeviceSize
    size*: VkDeviceSize

  VkImageMemoryBarrier* = object
    sType*: VkStructureType
    pNext*: pointer
    srcAccessMask*: VkAccessFlags
    dstAccessMask*: VkAccessFlags
    oldLayout*: VkImageLayout
    newLayout*: VkImageLayout
    srcQueueFamilyIndex*: uint32
    dstQueueFamilyIndex*: uint32
    image*: VkImage
    subresourceRange*: VkImageSubresourceRange

  VkImageCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkImageCreateFlags
    imageType*: VkImageType
    format*: VkFormat
    extent*: VkExtent3D
    mipLevels*: uint32
    arrayLayers*: uint32
    samples*: VkSampleCountFlagBits
    tiling*: VkImageTiling
    usage*: VkImageUsageFlags
    sharingMode*: VkSharingMode
    queueFamilyIndexCount*: uint32
    pQueueFamilyIndices*: ptr uint32
    initialLayout*: VkImageLayout

  VkSubresourceLayout* = object
    offset*: VkDeviceSize
    size*: VkDeviceSize
    rowPitch*: VkDeviceSize
    arrayPitch*: VkDeviceSize
    depthPitch*: VkDeviceSize

  VkImageViewCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkImageViewCreateFlags
    image*: VkImage
    viewType*: VkImageViewType
    format*: VkFormat
    components*: VkComponentMapping
    subresourceRange*: VkImageSubresourceRange

  VkBufferCopy* = object
    srcOffset*: VkDeviceSize
    dstOffset*: VkDeviceSize
    size*: VkDeviceSize

  VkSparseMemoryBind* = object
    resourceOffset*: VkDeviceSize
    size*: VkDeviceSize
    memory*: VkDeviceMemory
    memoryOffset*: VkDeviceSize
    flags*: VkSparseMemoryBindFlags

  VkSparseImageMemoryBind* = object
    subresource*: VkImageSubresource
    offset*: VkOffset3D
    extent*: VkExtent3D
    memory*: VkDeviceMemory
    memoryOffset*: VkDeviceSize
    flags*: VkSparseMemoryBindFlags

  VkSparseBufferMemoryBindInfo* = object
    buffer*: VkBuffer
    bindCount*: uint32
    pBinds*: ptr VkSparseMemoryBind

  VkSparseImageOpaqueMemoryBindInfo* = object
    image*: VkImage
    bindCount*: uint32
    pBinds*: ptr VkSparseMemoryBind

  VkSparseImageMemoryBindInfo* = object
    image*: VkImage
    bindCount*: uint32
    pBinds*: ptr VkSparseImageMemoryBind

  VkBindSparseInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    waitSemaphoreCount*: uint32
    pWaitSemaphores*: ptr VkSemaphore
    bufferBindCount*: uint32
    pBufferBinds*: ptr VkSparseBufferMemoryBindInfo
    imageOpaqueBindCount*: uint32
    pImageOpaqueBinds*: ptr VkSparseImageOpaqueMemoryBindInfo
    imageBindCount*: uint32
    pImageBinds*: ptr VkSparseImageMemoryBindInfo
    signalSemaphoreCount*: uint32
    pSignalSemaphores*: ptr VkSemaphore

  VkImageCopy* = object
    srcSubresource*: VkImageSubresourceLayers
    srcOffset*: VkOffset3D
    dstSubresource*: VkImageSubresourceLayers
    dstOffset*: VkOffset3D
    extent*: VkExtent3D

  VkImageBlit* = object
    srcSubresource*: VkImageSubresourceLayers
    srcOffsets*: array[2, VkOffset3D]
    dstSubresource*: VkImageSubresourceLayers
    dstOffsets*: array[2, VkOffset3D]

  VkBufferImageCopy* = object
    bufferOffset*: VkDeviceSize
    bufferRowLength*: uint32
    bufferImageHeight*: uint32
    imageSubresource*: VkImageSubresourceLayers
    imageOffset*: VkOffset3D
    imageExtent*: VkExtent3D

  VkImageResolve* = object
    srcSubresource*: VkImageSubresourceLayers
    srcOffset*: VkOffset3D
    dstSubresource*: VkImageSubresourceLayers
    dstOffset*: VkOffset3D
    extent*: VkExtent3D

  VkShaderModuleCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkShaderModuleCreateFlags
    codeSize*: uint
    pCode*: ptr uint32

  VkDescriptorSetLayoutBinding* = object
    binding*: uint32
    descriptorType*: VkDescriptorType
    descriptorCount*: uint32
    stageFlags*: VkShaderStageFlags
    pImmutableSamplers*: ptr VkSampler

  VkDescriptorSetLayoutCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDescriptorSetLayoutCreateFlags
    bindingCount*: uint32
    pBindings*: ptr VkDescriptorSetLayoutBinding

  VkDescriptorPoolSize* = object
    `type`*: VkDescriptorType
    descriptorCount*: uint32

  VkDescriptorPoolCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDescriptorPoolCreateFlags
    maxSets*: uint32
    poolSizeCount*: uint32
    pPoolSizes*: ptr VkDescriptorPoolSize

  VkDescriptorSetAllocateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    descriptorPool*: VkDescriptorPool
    descriptorSetCount*: uint32
    pSetLayouts*: ptr VkDescriptorSetLayout

  VkSpecializationMapEntry* = object
    constantID*: uint32
    offset*: uint32
    size*: uint

  VkSpecializationInfo* = object
    mapEntryCount*: uint32
    pMapEntries*: ptr VkSpecializationMapEntry
    dataSize*: uint
    pData*: pointer

  VkPipelineShaderStageCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineShaderStageCreateFlags
    stage*: VkShaderStageFlagBits
    module*: VkShaderModule
    pName*: cstring
    pSpecializationInfo*: ptr VkSpecializationInfo

  VkComputePipelineCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineCreateFlags
    stage*: VkPipelineShaderStageCreateInfo
    layout*: VkPipelineLayout
    basePipelineHandle*: VkPipeline
    basePipelineIndex*: int32

  VkVertexInputBindingDescription* = object
    binding*: uint32
    stride*: uint32
    inputRate*: VkVertexInputRate

  VkVertexInputAttributeDescription* = object
    location*: uint32
    binding*: uint32
    format*: VkFormat
    offset*: uint32

  VkPipelineVertexInputStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineVertexInputStateCreateFlags
    vertexBindingDescriptionCount*: uint32
    pVertexBindingDescriptions*: ptr VkVertexInputBindingDescription
    vertexAttributeDescriptionCount*: uint32
    pVertexAttributeDescriptions*: ptr VkVertexInputAttributeDescription

  VkPipelineInputAssemblyStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineInputAssemblyStateCreateFlags
    topology*: VkPrimitiveTopology
    primitiveRestartEnable*: VkBool32

  VkPipelineTessellationStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineTessellationStateCreateFlags
    patchControlPoints*: uint32

  VkPipelineViewportStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineViewportStateCreateFlags
    viewportCount*: uint32
    pViewports*: ptr VkViewport
    scissorCount*: uint32
    pScissors*: ptr VkRect2D

  VkPipelineRasterizationStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineRasterizationStateCreateFlags
    depthClampEnable*: VkBool32
    rasterizerDiscardEnable*: VkBool32
    polygonMode*: VkPolygonMode
    cullMode*: VkCullModeFlags
    frontFace*: VkFrontFace
    depthBiasEnable*: VkBool32
    depthBiasConstantFactor*: float32
    depthBiasClamp*: float32
    depthBiasSlopeFactor*: float32
    lineWidth*: float32

  VkPipelineMultisampleStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineMultisampleStateCreateFlags
    rasterizationSamples*: VkSampleCountFlagBits
    sampleShadingEnable*: VkBool32
    minSampleShading*: float32
    pSampleMask*: ptr VkSampleMask
    alphaToCoverageEnable*: VkBool32
    alphaToOneEnable*: VkBool32

  VkPipelineColorBlendAttachmentState* = object
    blendEnable*: VkBool32
    srcColorBlendFactor*: VkBlendFactor
    dstColorBlendFactor*: VkBlendFactor
    colorBlendOp*: VkBlendOp
    srcAlphaBlendFactor*: VkBlendFactor
    dstAlphaBlendFactor*: VkBlendFactor
    alphaBlendOp*: VkBlendOp
    colorWriteMask*: VkColorComponentFlags

  VkPipelineColorBlendStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineColorBlendStateCreateFlags
    logicOpEnable*: VkBool32
    logicOp*: VkLogicOp
    attachmentCount*: uint32
    pAttachments*: ptr VkPipelineColorBlendAttachmentState
    blendConstants*: array[4, float32]

  VkPipelineDynamicStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineDynamicStateCreateFlags
    dynamicStateCount*: uint32
    pDynamicStates*: ptr VkDynamicState

  VkStencilOpState* = object
    failOp*: VkStencilOp
    passOp*: VkStencilOp
    depthFailOp*: VkStencilOp
    compareOp*: VkCompareOp
    compareMask*: uint32
    writeMask*: uint32
    reference*: uint32

  VkPipelineDepthStencilStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineDepthStencilStateCreateFlags
    depthTestEnable*: VkBool32
    depthWriteEnable*: VkBool32
    depthCompareOp*: VkCompareOp
    depthBoundsTestEnable*: VkBool32
    stencilTestEnable*: VkBool32
    front*: VkStencilOpState
    back*: VkStencilOpState
    minDepthBounds*: float32
    maxDepthBounds*: float32

  VkGraphicsPipelineCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineCreateFlags
    stageCount*: uint32
    pStages*: ptr VkPipelineShaderStageCreateInfo
    pVertexInputState*: ptr VkPipelineVertexInputStateCreateInfo
    pInputAssemblyState*: ptr VkPipelineInputAssemblyStateCreateInfo
    pTessellationState*: ptr VkPipelineTessellationStateCreateInfo
    pViewportState*: ptr VkPipelineViewportStateCreateInfo
    pRasterizationState*: ptr VkPipelineRasterizationStateCreateInfo
    pMultisampleState*: ptr VkPipelineMultisampleStateCreateInfo
    pDepthStencilState*: ptr VkPipelineDepthStencilStateCreateInfo
    pColorBlendState*: ptr VkPipelineColorBlendStateCreateInfo
    pDynamicState*: ptr VkPipelineDynamicStateCreateInfo
    layout*: VkPipelineLayout
    renderPass*: VkRenderPass
    subpass*: uint32
    basePipelineHandle*: VkPipeline
    basePipelineIndex*: int32

  VkPipelineCacheCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineCacheCreateFlags
    initialDataSize*: uint
    pInitialData*: pointer

  VkPushConstantRange* = object
    stageFlags*: VkShaderStageFlags
    offset*: uint32
    size*: uint32

  VkPipelineLayoutCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineLayoutCreateFlags
    setLayoutCount*: uint32
    pSetLayouts*: ptr VkDescriptorSetLayout
    pushConstantRangeCount*: uint32
    pPushConstantRanges*: ptr VkPushConstantRange

  VkSamplerCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkSamplerCreateFlags
    magFilter*: VkFilter
    minFilter*: VkFilter
    mipmapMode*: VkSamplerMipmapMode
    addressModeU*: VkSamplerAddressMode
    addressModeV*: VkSamplerAddressMode
    addressModeW*: VkSamplerAddressMode
    mipLodBias*: float32
    anisotropyEnable*: VkBool32
    maxAnisotropy*: float32
    compareEnable*: VkBool32
    compareOp*: VkCompareOp
    minLod*: float32
    maxLod*: float32
    borderColor*: VkBorderColor
    unnormalizedCoordinates*: VkBool32

  VkCommandPoolCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkCommandPoolCreateFlags
    queueFamilyIndex*: uint32

  VkCommandBufferAllocateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    commandPool*: VkCommandPool
    level*: VkCommandBufferLevel
    commandBufferCount*: uint32

  VkCommandBufferInheritanceInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    renderPass*: VkRenderPass
    subpass*: uint32
    framebuffer*: VkFramebuffer
    occlusionQueryEnable*: VkBool32
    queryFlags*: VkQueryControlFlags
    pipelineStatistics*: VkQueryPipelineStatisticFlags

  VkCommandBufferBeginInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkCommandBufferUsageFlags
    pInheritanceInfo*: ptr VkCommandBufferInheritanceInfo

  VkRenderPassBeginInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    renderPass*: VkRenderPass
    framebuffer*: VkFramebuffer
    renderArea*: VkRect2D
    clearValueCount*: uint32
    pClearValues*: ptr VkClearValue

  VkClearColorValue* {.union.} = object
    float32*: array[4, float32]
    int32*: array[4, int32]
    uint32*: array[4, uint32]

  VkClearDepthStencilValue* = object
    depth*: float32
    stencil*: uint32

  VkClearValue* {.union.} = object
    color*: VkClearColorValue
    depthStencil*: VkClearDepthStencilValue

  VkClearAttachment* = object
    aspectMask*: VkImageAspectFlags
    colorAttachment*: uint32
    clearValue*: VkClearValue

  VkAttachmentDescription* = object
    flags*: VkAttachmentDescriptionFlags
    format*: VkFormat
    samples*: VkSampleCountFlagBits
    loadOp*: VkAttachmentLoadOp
    storeOp*: VkAttachmentStoreOp
    stencilLoadOp*: VkAttachmentLoadOp
    stencilStoreOp*: VkAttachmentStoreOp
    initialLayout*: VkImageLayout
    finalLayout*: VkImageLayout

  VkAttachmentReference* = object
    attachment*: uint32
    layout*: VkImageLayout

  VkSubpassDescription* = object
    flags*: VkSubpassDescriptionFlags
    pipelineBindPoint*: VkPipelineBindPoint
    inputAttachmentCount*: uint32
    pInputAttachments*: ptr VkAttachmentReference
    colorAttachmentCount*: uint32
    pColorAttachments*: ptr VkAttachmentReference
    pResolveAttachments*: ptr VkAttachmentReference
    pDepthStencilAttachment*: ptr VkAttachmentReference
    preserveAttachmentCount*: uint32
    pPreserveAttachments*: ptr uint32

  VkSubpassDependency* = object
    srcSubpass*: uint32
    dstSubpass*: uint32
    srcStageMask*: VkPipelineStageFlags
    dstStageMask*: VkPipelineStageFlags
    srcAccessMask*: VkAccessFlags
    dstAccessMask*: VkAccessFlags
    dependencyFlags*: VkDependencyFlags

  VkRenderPassCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkRenderPassCreateFlags
    attachmentCount*: uint32
    pAttachments*: ptr VkAttachmentDescription
    subpassCount*: uint32
    pSubpasses*: ptr VkSubpassDescription
    dependencyCount*: uint32
    pDependencies*: ptr VkSubpassDependency

  VkEventCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkEventCreateFlags

  VkFenceCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkFenceCreateFlags

  VkPhysicalDeviceFeatures* = object
    robustBufferAccess*: VkBool32
    fullDrawIndexUint32*: VkBool32
    imageCubeArray*: VkBool32
    independentBlend*: VkBool32
    geometryShader*: VkBool32
    tessellationShader*: VkBool32
    sampleRateShading*: VkBool32
    dualSrcBlend*: VkBool32
    logicOp*: VkBool32
    multiDrawIndirect*: VkBool32
    drawIndirectFirstInstance*: VkBool32
    depthClamp*: VkBool32
    depthBiasClamp*: VkBool32
    fillModeNonSolid*: VkBool32
    depthBounds*: VkBool32
    wideLines*: VkBool32
    largePoints*: VkBool32
    alphaToOne*: VkBool32
    multiViewport*: VkBool32
    samplerAnisotropy*: VkBool32
    textureCompressionETC2*: VkBool32
    textureCompressionASTC_LDR*: VkBool32
    textureCompressionBC*: VkBool32
    occlusionQueryPrecise*: VkBool32
    pipelineStatisticsQuery*: VkBool32
    vertexPipelineStoresAndAtomics*: VkBool32
    fragmentStoresAndAtomics*: VkBool32
    shaderTessellationAndGeometryPointSize*: VkBool32
    shaderImageGatherExtended*: VkBool32
    shaderStorageImageExtendedFormats*: VkBool32
    shaderStorageImageMultisample*: VkBool32
    shaderStorageImageReadWithoutFormat*: VkBool32
    shaderStorageImageWriteWithoutFormat*: VkBool32
    shaderUniformBufferArrayDynamicIndexing*: VkBool32
    shaderSampledImageArrayDynamicIndexing*: VkBool32
    shaderStorageBufferArrayDynamicIndexing*: VkBool32
    shaderStorageImageArrayDynamicIndexing*: VkBool32
    shaderClipDistance*: VkBool32
    shaderCullDistance*: VkBool32
    shaderFloat64*: VkBool32
    shaderInt64*: VkBool32
    shaderInt16*: VkBool32
    shaderResourceResidency*: VkBool32
    shaderResourceMinLod*: VkBool32
    sparseBinding*: VkBool32
    sparseResidencyBuffer*: VkBool32
    sparseResidencyImage2D*: VkBool32
    sparseResidencyImage3D*: VkBool32
    sparseResidency2Samples*: VkBool32
    sparseResidency4Samples*: VkBool32
    sparseResidency8Samples*: VkBool32
    sparseResidency16Samples*: VkBool32
    sparseResidencyAliased*: VkBool32
    variableMultisampleRate*: VkBool32
    inheritedQueries*: VkBool32

  VkPhysicalDeviceSparseProperties* = object
    residencyStandard2DBlockShape*: VkBool32
    residencyStandard2DMultisampleBlockShape*: VkBool32
    residencyStandard3DBlockShape*: VkBool32
    residencyAlignedMipSize*: VkBool32
    residencyNonResidentStrict*: VkBool32

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

  VkSemaphoreCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkSemaphoreCreateFlags

  VkQueryPoolCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkQueryPoolCreateFlags
    queryType*: VkQueryType
    queryCount*: uint32
    pipelineStatistics*: VkQueryPipelineStatisticFlags

  VkFramebufferCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkFramebufferCreateFlags
    renderPass*: VkRenderPass
    attachmentCount*: uint32
    pAttachments*: ptr VkImageView
    width*: uint32
    height*: uint32
    layers*: uint32

  VkDrawIndirectCommand* = object
    vertexCount*: uint32
    instanceCount*: uint32
    firstVertex*: uint32
    firstInstance*: uint32

  VkDrawIndexedIndirectCommand* = object
    indexCount*: uint32
    instanceCount*: uint32
    firstIndex*: uint32
    vertexOffset*: int32
    firstInstance*: uint32

  VkDispatchIndirectCommand* = object
    x*: uint32
    y*: uint32
    z*: uint32

  VkSubmitInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    waitSemaphoreCount*: uint32
    pWaitSemaphores*: ptr VkSemaphore
    pWaitDstStageMask*: ptr VkPipelineStageFlags
    commandBufferCount*: uint32
    pCommandBuffers*: ptr VkCommandBuffer
    signalSemaphoreCount*: uint32
    pSignalSemaphores*: ptr VkSemaphore

  VkDisplayPropertiesKHR* = object
    display*: VkDisplayKHR
    displayName*: cstring
    physicalDimensions*: VkExtent2D
    physicalResolution*: VkExtent2D
    supportedTransforms*: VkSurfaceTransformFlagsKHR
    planeReorderPossible*: VkBool32
    persistentContent*: VkBool32

  VkDisplayPlanePropertiesKHR* = object
    currentDisplay*: VkDisplayKHR
    currentStackIndex*: uint32

  VkDisplayModeParametersKHR* = object
    visibleRegion*: VkExtent2D
    refreshRate*: uint32

  VkDisplayModePropertiesKHR* = object
    displayMode*: VkDisplayModeKHR
    parameters*: VkDisplayModeParametersKHR

  VkDisplayModeCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDisplayModeCreateFlagsKHR
    parameters*: VkDisplayModeParametersKHR

  VkDisplayPlaneCapabilitiesKHR* = object
    supportedAlpha*: VkDisplayPlaneAlphaFlagsKHR
    minSrcPosition*: VkOffset2D
    maxSrcPosition*: VkOffset2D
    minSrcExtent*: VkExtent2D
    maxSrcExtent*: VkExtent2D
    minDstPosition*: VkOffset2D
    maxDstPosition*: VkOffset2D
    minDstExtent*: VkExtent2D
    maxDstExtent*: VkExtent2D

  VkDisplaySurfaceCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDisplaySurfaceCreateFlagsKHR
    displayMode*: VkDisplayModeKHR
    planeIndex*: uint32
    planeStackIndex*: uint32
    transform*: VkSurfaceTransformFlagBitsKHR
    globalAlpha*: float32
    alphaMode*: VkDisplayPlaneAlphaFlagBitsKHR
    imageExtent*: VkExtent2D

  VkDisplayPresentInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    srcRect*: VkRect2D
    dstRect*: VkRect2D
    persistent*: VkBool32

  VkSurfaceCapabilitiesKHR* = object
    minImageCount*: uint32
    maxImageCount*: uint32
    currentExtent*: VkExtent2D
    minImageExtent*: VkExtent2D
    maxImageExtent*: VkExtent2D
    maxImageArrayLayers*: uint32
    supportedTransforms*: VkSurfaceTransformFlagsKHR
    currentTransform*: VkSurfaceTransformFlagBitsKHR
    supportedCompositeAlpha*: VkCompositeAlphaFlagsKHR
    supportedUsageFlags*: VkImageUsageFlags

  VkAndroidSurfaceCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkAndroidSurfaceCreateFlagsKHR
    window*: ptr ANativeWindow

  VkViSurfaceCreateInfoNN* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkViSurfaceCreateFlagsNN
    window*: pointer

  VkWaylandSurfaceCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkWaylandSurfaceCreateFlagsKHR
    display*: ptr wl_display
    surface*: ptr wl_surface

  VkWin32SurfaceCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkWin32SurfaceCreateFlagsKHR
    hinstance*: HINSTANCE
    hwnd*: HWND

  VkXlibSurfaceCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkXlibSurfaceCreateFlagsKHR
    dpy*: ptr Display
    window*: Window

  VkXcbSurfaceCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkXcbSurfaceCreateFlagsKHR
    connection*: ptr xcb_connection_t
    window*: xcb_window_t

  VkDirectFBSurfaceCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDirectFBSurfaceCreateFlagsEXT
    dfb*: ptr IDirectFB
    surface*: ptr IDirectFBSurface

  VkImagePipeSurfaceCreateInfoFUCHSIA* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkImagePipeSurfaceCreateFlagsFUCHSIA
    imagePipeHandle*: zx_handle_t

  VkStreamDescriptorSurfaceCreateInfoGGP* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkStreamDescriptorSurfaceCreateFlagsGGP
    streamDescriptor*: GgpStreamDescriptor

  VkSurfaceFormatKHR* = object
    format*: VkFormat
    colorSpace*: VkColorSpaceKHR

  VkSwapchainCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkSwapchainCreateFlagsKHR
    surface*: VkSurfaceKHR
    minImageCount*: uint32
    imageFormat*: VkFormat
    imageColorSpace*: VkColorSpaceKHR
    imageExtent*: VkExtent2D
    imageArrayLayers*: uint32
    imageUsage*: VkImageUsageFlags
    imageSharingMode*: VkSharingMode
    queueFamilyIndexCount*: uint32
    pQueueFamilyIndices*: ptr uint32
    preTransform*: VkSurfaceTransformFlagBitsKHR
    compositeAlpha*: VkCompositeAlphaFlagBitsKHR
    presentMode*: VkPresentModeKHR
    clipped*: VkBool32
    oldSwapchain*: VkSwapchainKHR

  VkPresentInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    waitSemaphoreCount*: uint32
    pWaitSemaphores*: ptr VkSemaphore
    swapchainCount*: uint32
    pSwapchains*: ptr VkSwapchainKHR
    pImageIndices*: ptr uint32
    pResults*: ptr VkResult

  VkDebugReportCallbackCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDebugReportFlagsEXT
    pfnCallback*: PFN_vkDebugReportCallbackEXT
    pUserData*: pointer

  VkValidationFlagsEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    disabledValidationCheckCount*: uint32
    pDisabledValidationChecks*: ptr VkValidationCheckEXT

  VkValidationFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    enabledValidationFeatureCount*: uint32
    pEnabledValidationFeatures*: ptr VkValidationFeatureEnableEXT
    disabledValidationFeatureCount*: uint32
    pDisabledValidationFeatures*: ptr VkValidationFeatureDisableEXT

  VkPipelineRasterizationStateRasterizationOrderAMD* = object
    sType*: VkStructureType
    pNext*: pointer
    rasterizationOrder*: VkRasterizationOrderAMD

  VkDebugMarkerObjectNameInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    objectType*: VkDebugReportObjectTypeEXT
    `object`*: uint64
    pObjectName*: cstring

  VkDebugMarkerObjectTagInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    objectType*: VkDebugReportObjectTypeEXT
    `object`*: uint64
    tagName*: uint64
    tagSize*: uint
    pTag*: pointer

  VkDebugMarkerMarkerInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    pMarkerName*: cstring
    color*: array[4, float32]

  VkDedicatedAllocationImageCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    dedicatedAllocation*: VkBool32

  VkDedicatedAllocationBufferCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    dedicatedAllocation*: VkBool32

  VkDedicatedAllocationMemoryAllocateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    image*: VkImage
    buffer*: VkBuffer

  VkExternalImageFormatPropertiesNV* = object
    imageFormatProperties*: VkImageFormatProperties
    externalMemoryFeatures*: VkExternalMemoryFeatureFlagsNV
    exportFromImportedHandleTypes*: VkExternalMemoryHandleTypeFlagsNV
    compatibleHandleTypes*: VkExternalMemoryHandleTypeFlagsNV

  VkExternalMemoryImageCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    handleTypes*: VkExternalMemoryHandleTypeFlagsNV

  VkExportMemoryAllocateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    handleTypes*: VkExternalMemoryHandleTypeFlagsNV

  VkImportMemoryWin32HandleInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    handleType*: VkExternalMemoryHandleTypeFlagsNV
    handle*: HANDLE

  VkExportMemoryWin32HandleInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    pAttributes*: ptr SECURITY_ATTRIBUTES
    dwAccess*: DWORD

  VkWin32KeyedMutexAcquireReleaseInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    acquireCount*: uint32
    pAcquireSyncs*: ptr VkDeviceMemory
    pAcquireKeys*: ptr uint64
    pAcquireTimeoutMilliseconds*: ptr uint32
    releaseCount*: uint32
    pReleaseSyncs*: ptr VkDeviceMemory
    pReleaseKeys*: ptr uint64

  VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceGeneratedCommands*: VkBool32

  VkDevicePrivateDataCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    privateDataSlotRequestCount*: uint32

  VkPrivateDataSlotCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPrivateDataSlotCreateFlagsEXT

  VkPhysicalDevicePrivateDataFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    privateData*: VkBool32

  VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    maxGraphicsShaderGroupCount*: uint32
    maxIndirectSequenceCount*: uint32
    maxIndirectCommandsTokenCount*: uint32
    maxIndirectCommandsStreamCount*: uint32
    maxIndirectCommandsTokenOffset*: uint32
    maxIndirectCommandsStreamStride*: uint32
    minSequencesCountBufferOffsetAlignment*: uint32
    minSequencesIndexBufferOffsetAlignment*: uint32
    minIndirectCommandsBufferOffsetAlignment*: uint32

  VkGraphicsShaderGroupCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    stageCount*: uint32
    pStages*: ptr VkPipelineShaderStageCreateInfo
    pVertexInputState*: ptr VkPipelineVertexInputStateCreateInfo
    pTessellationState*: ptr VkPipelineTessellationStateCreateInfo

  VkGraphicsPipelineShaderGroupsCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    groupCount*: uint32
    pGroups*: ptr VkGraphicsShaderGroupCreateInfoNV
    pipelineCount*: uint32
    pPipelines*: ptr VkPipeline

  VkBindShaderGroupIndirectCommandNV* = object
    groupIndex*: uint32

  VkBindIndexBufferIndirectCommandNV* = object
    bufferAddress*: VkDeviceAddress
    size*: uint32
    indexType*: VkIndexType

  VkBindVertexBufferIndirectCommandNV* = object
    bufferAddress*: VkDeviceAddress
    size*: uint32
    stride*: uint32

  VkSetStateFlagsIndirectCommandNV* = object
    data*: uint32

  VkIndirectCommandsStreamNV* = object
    buffer*: VkBuffer
    offset*: VkDeviceSize

  VkIndirectCommandsLayoutTokenNV* = object
    sType*: VkStructureType
    pNext*: pointer
    tokenType*: VkIndirectCommandsTokenTypeNV
    stream*: uint32
    offset*: uint32
    vertexBindingUnit*: uint32
    vertexDynamicStride*: VkBool32
    pushconstantPipelineLayout*: VkPipelineLayout
    pushconstantShaderStageFlags*: VkShaderStageFlags
    pushconstantOffset*: uint32
    pushconstantSize*: uint32
    indirectStateFlags*: VkIndirectStateFlagsNV
    indexTypeCount*: uint32
    pIndexTypes*: ptr VkIndexType
    pIndexTypeValues*: ptr uint32

  VkIndirectCommandsLayoutCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkIndirectCommandsLayoutUsageFlagsNV
    pipelineBindPoint*: VkPipelineBindPoint
    tokenCount*: uint32
    pTokens*: ptr VkIndirectCommandsLayoutTokenNV
    streamCount*: uint32
    pStreamStrides*: ptr uint32

  VkGeneratedCommandsInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    pipelineBindPoint*: VkPipelineBindPoint
    pipeline*: VkPipeline
    indirectCommandsLayout*: VkIndirectCommandsLayoutNV
    streamCount*: uint32
    pStreams*: ptr VkIndirectCommandsStreamNV
    sequencesCount*: uint32
    preprocessBuffer*: VkBuffer
    preprocessOffset*: VkDeviceSize
    preprocessSize*: VkDeviceSize
    sequencesCountBuffer*: VkBuffer
    sequencesCountOffset*: VkDeviceSize
    sequencesIndexBuffer*: VkBuffer
    sequencesIndexOffset*: VkDeviceSize

  VkGeneratedCommandsMemoryRequirementsInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    pipelineBindPoint*: VkPipelineBindPoint
    pipeline*: VkPipeline
    indirectCommandsLayout*: VkIndirectCommandsLayoutNV
    maxSequencesCount*: uint32

  VkPhysicalDeviceFeatures2* = object
    sType*: VkStructureType
    pNext*: pointer
    features*: VkPhysicalDeviceFeatures

  VkPhysicalDeviceFeatures2KHR* = object

  VkPhysicalDeviceProperties2* = object
    sType*: VkStructureType
    pNext*: pointer
    properties*: VkPhysicalDeviceProperties

  VkPhysicalDeviceProperties2KHR* = object

  VkFormatProperties2* = object
    sType*: VkStructureType
    pNext*: pointer
    formatProperties*: VkFormatProperties

  VkFormatProperties2KHR* = object

  VkImageFormatProperties2* = object
    sType*: VkStructureType
    pNext*: pointer
    imageFormatProperties*: VkImageFormatProperties

  VkImageFormatProperties2KHR* = object

  VkPhysicalDeviceImageFormatInfo2* = object
    sType*: VkStructureType
    pNext*: pointer
    format*: VkFormat
    `type`*: VkImageType
    tiling*: VkImageTiling
    usage*: VkImageUsageFlags
    flags*: VkImageCreateFlags

  VkPhysicalDeviceImageFormatInfo2KHR* = object

  VkQueueFamilyProperties2* = object
    sType*: VkStructureType
    pNext*: pointer
    queueFamilyProperties*: VkQueueFamilyProperties

  VkQueueFamilyProperties2KHR* = object

  VkPhysicalDeviceMemoryProperties2* = object
    sType*: VkStructureType
    pNext*: pointer
    memoryProperties*: VkPhysicalDeviceMemoryProperties

  VkPhysicalDeviceMemoryProperties2KHR* = object

  VkSparseImageFormatProperties2* = object
    sType*: VkStructureType
    pNext*: pointer
    properties*: VkSparseImageFormatProperties

  VkSparseImageFormatProperties2KHR* = object

  VkPhysicalDeviceSparseImageFormatInfo2* = object
    sType*: VkStructureType
    pNext*: pointer
    format*: VkFormat
    `type`*: VkImageType
    samples*: VkSampleCountFlagBits
    usage*: VkImageUsageFlags
    tiling*: VkImageTiling

  VkPhysicalDeviceSparseImageFormatInfo2KHR* = object

  VkPhysicalDevicePushDescriptorPropertiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    maxPushDescriptors*: uint32

  VkConformanceVersion* = object
    major*: uint8
    minor*: uint8
    subminor*: uint8
    patch*: uint8

  VkConformanceVersionKHR* = object

  VkPhysicalDeviceDriverProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    driverID*: VkDriverId
    driverName*: array[VK_MAX_DRIVER_NAME_SIZE, char]
    driverInfo*: array[VK_MAX_DRIVER_INFO_SIZE, char]
    conformanceVersion*: VkConformanceVersion

  VkPhysicalDeviceDriverPropertiesKHR* = object

  VkPresentRegionsKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    swapchainCount*: uint32
    pRegions*: ptr VkPresentRegionKHR

  VkPresentRegionKHR* = object
    rectangleCount*: uint32
    pRectangles*: ptr VkRectLayerKHR

  VkRectLayerKHR* = object
    offset*: VkOffset2D
    extent*: VkExtent2D
    layer*: uint32

  VkPhysicalDeviceVariablePointersFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    variablePointersStorageBuffer*: VkBool32
    variablePointers*: VkBool32

  VkPhysicalDeviceVariablePointersFeaturesKHR* = object

  VkPhysicalDeviceVariablePointerFeaturesKHR* = object

  VkPhysicalDeviceVariablePointerFeatures* = object

  VkExternalMemoryProperties* = object
    externalMemoryFeatures*: VkExternalMemoryFeatureFlags
    exportFromImportedHandleTypes*: VkExternalMemoryHandleTypeFlags
    compatibleHandleTypes*: VkExternalMemoryHandleTypeFlags

  VkExternalMemoryPropertiesKHR* = object

  VkPhysicalDeviceExternalImageFormatInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    handleType*: VkExternalMemoryHandleTypeFlagBits

  VkPhysicalDeviceExternalImageFormatInfoKHR* = object

  VkExternalImageFormatProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    externalMemoryProperties*: VkExternalMemoryProperties

  VkExternalImageFormatPropertiesKHR* = object

  VkPhysicalDeviceExternalBufferInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkBufferCreateFlags
    usage*: VkBufferUsageFlags
    handleType*: VkExternalMemoryHandleTypeFlagBits

  VkPhysicalDeviceExternalBufferInfoKHR* = object

  VkExternalBufferProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    externalMemoryProperties*: VkExternalMemoryProperties

  VkExternalBufferPropertiesKHR* = object

  VkPhysicalDeviceIDProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceUUID*: array[VK_UUID_SIZE, uint8]
    driverUUID*: array[VK_UUID_SIZE, uint8]
    deviceLUID*: array[VK_LUID_SIZE, uint8]
    deviceNodeMask*: uint32
    deviceLUIDValid*: VkBool32

  VkPhysicalDeviceIDPropertiesKHR* = object

  VkExternalMemoryImageCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    handleTypes*: VkExternalMemoryHandleTypeFlags

  VkExternalMemoryImageCreateInfoKHR* = object

  VkExternalMemoryBufferCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    handleTypes*: VkExternalMemoryHandleTypeFlags

  VkExternalMemoryBufferCreateInfoKHR* = object

  VkExportMemoryAllocateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    handleTypes*: VkExternalMemoryHandleTypeFlags

  VkExportMemoryAllocateInfoKHR* = object

  VkImportMemoryWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    handleType*: VkExternalMemoryHandleTypeFlagBits
    handle*: HANDLE
    name*: LPCWSTR

  VkExportMemoryWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    pAttributes*: ptr SECURITY_ATTRIBUTES
    dwAccess*: DWORD
    name*: LPCWSTR

  VkMemoryWin32HandlePropertiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    memoryTypeBits*: uint32

  VkMemoryGetWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    memory*: VkDeviceMemory
    handleType*: VkExternalMemoryHandleTypeFlagBits

  VkImportMemoryFdInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    handleType*: VkExternalMemoryHandleTypeFlagBits
    fd*: int

  VkMemoryFdPropertiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    memoryTypeBits*: uint32

  VkMemoryGetFdInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    memory*: VkDeviceMemory
    handleType*: VkExternalMemoryHandleTypeFlagBits

  VkWin32KeyedMutexAcquireReleaseInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    acquireCount*: uint32
    pAcquireSyncs*: ptr VkDeviceMemory
    pAcquireKeys*: ptr uint64
    pAcquireTimeouts*: ptr uint32
    releaseCount*: uint32
    pReleaseSyncs*: ptr VkDeviceMemory
    pReleaseKeys*: ptr uint64

  VkPhysicalDeviceExternalSemaphoreInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    handleType*: VkExternalSemaphoreHandleTypeFlagBits

  VkPhysicalDeviceExternalSemaphoreInfoKHR* = object

  VkExternalSemaphoreProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    exportFromImportedHandleTypes*: VkExternalSemaphoreHandleTypeFlags
    compatibleHandleTypes*: VkExternalSemaphoreHandleTypeFlags
    externalSemaphoreFeatures*: VkExternalSemaphoreFeatureFlags

  VkExternalSemaphorePropertiesKHR* = object

  VkExportSemaphoreCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    handleTypes*: VkExternalSemaphoreHandleTypeFlags

  VkExportSemaphoreCreateInfoKHR* = object

  VkImportSemaphoreWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    semaphore*: VkSemaphore
    flags*: VkSemaphoreImportFlags
    handleType*: VkExternalSemaphoreHandleTypeFlagBits
    handle*: HANDLE
    name*: LPCWSTR

  VkExportSemaphoreWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    pAttributes*: ptr SECURITY_ATTRIBUTES
    dwAccess*: DWORD
    name*: LPCWSTR

  VkD3D12FenceSubmitInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    waitSemaphoreValuesCount*: uint32
    pWaitSemaphoreValues*: ptr uint64
    signalSemaphoreValuesCount*: uint32
    pSignalSemaphoreValues*: ptr uint64

  VkSemaphoreGetWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    semaphore*: VkSemaphore
    handleType*: VkExternalSemaphoreHandleTypeFlagBits

  VkImportSemaphoreFdInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    semaphore*: VkSemaphore
    flags*: VkSemaphoreImportFlags
    handleType*: VkExternalSemaphoreHandleTypeFlagBits
    fd*: int

  VkSemaphoreGetFdInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    semaphore*: VkSemaphore
    handleType*: VkExternalSemaphoreHandleTypeFlagBits

  VkPhysicalDeviceExternalFenceInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    handleType*: VkExternalFenceHandleTypeFlagBits

  VkPhysicalDeviceExternalFenceInfoKHR* = object

  VkExternalFenceProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    exportFromImportedHandleTypes*: VkExternalFenceHandleTypeFlags
    compatibleHandleTypes*: VkExternalFenceHandleTypeFlags
    externalFenceFeatures*: VkExternalFenceFeatureFlags

  VkExternalFencePropertiesKHR* = object

  VkExportFenceCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    handleTypes*: VkExternalFenceHandleTypeFlags

  VkExportFenceCreateInfoKHR* = object

  VkImportFenceWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    fence*: VkFence
    flags*: VkFenceImportFlags
    handleType*: VkExternalFenceHandleTypeFlagBits
    handle*: HANDLE
    name*: LPCWSTR

  VkExportFenceWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    pAttributes*: ptr SECURITY_ATTRIBUTES
    dwAccess*: DWORD
    name*: LPCWSTR

  VkFenceGetWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    fence*: VkFence
    handleType*: VkExternalFenceHandleTypeFlagBits

  VkImportFenceFdInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    fence*: VkFence
    flags*: VkFenceImportFlags
    handleType*: VkExternalFenceHandleTypeFlagBits
    fd*: int

  VkFenceGetFdInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    fence*: VkFence
    handleType*: VkExternalFenceHandleTypeFlagBits

  VkPhysicalDeviceMultiviewFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    multiview*: VkBool32
    multiviewGeometryShader*: VkBool32
    multiviewTessellationShader*: VkBool32

  VkPhysicalDeviceMultiviewFeaturesKHR* = object

  VkPhysicalDeviceMultiviewProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    maxMultiviewViewCount*: uint32
    maxMultiviewInstanceIndex*: uint32

  VkPhysicalDeviceMultiviewPropertiesKHR* = object

  VkRenderPassMultiviewCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    subpassCount*: uint32
    pViewMasks*: ptr uint32
    dependencyCount*: uint32
    pViewOffsets*: ptr int32
    correlationMaskCount*: uint32
    pCorrelationMasks*: ptr uint32

  VkRenderPassMultiviewCreateInfoKHR* = object

  VkSurfaceCapabilities2EXT* = object
    sType*: VkStructureType
    pNext*: pointer
    minImageCount*: uint32
    maxImageCount*: uint32
    currentExtent*: VkExtent2D
    minImageExtent*: VkExtent2D
    maxImageExtent*: VkExtent2D
    maxImageArrayLayers*: uint32
    supportedTransforms*: VkSurfaceTransformFlagsKHR
    currentTransform*: VkSurfaceTransformFlagBitsKHR
    supportedCompositeAlpha*: VkCompositeAlphaFlagsKHR
    supportedUsageFlags*: VkImageUsageFlags
    supportedSurfaceCounters*: VkSurfaceCounterFlagsEXT

  VkDisplayPowerInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    powerState*: VkDisplayPowerStateEXT

  VkDeviceEventInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceEvent*: VkDeviceEventTypeEXT

  VkDisplayEventInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    displayEvent*: VkDisplayEventTypeEXT

  VkSwapchainCounterCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    surfaceCounters*: VkSurfaceCounterFlagsEXT

  VkPhysicalDeviceGroupProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    physicalDeviceCount*: uint32
    physicalDevices*: array[VK_MAX_DEVICE_GROUP_SIZE, VkPhysicalDevice]
    subsetAllocation*: VkBool32

  VkPhysicalDeviceGroupPropertiesKHR* = object

  VkMemoryAllocateFlagsInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkMemoryAllocateFlags
    deviceMask*: uint32

  VkMemoryAllocateFlagsInfoKHR* = object

  VkBindBufferMemoryInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    buffer*: VkBuffer
    memory*: VkDeviceMemory
    memoryOffset*: VkDeviceSize

  VkBindBufferMemoryInfoKHR* = object

  VkBindBufferMemoryDeviceGroupInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceIndexCount*: uint32
    pDeviceIndices*: ptr uint32

  VkBindBufferMemoryDeviceGroupInfoKHR* = object

  VkBindImageMemoryInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    image*: VkImage
    memory*: VkDeviceMemory
    memoryOffset*: VkDeviceSize

  VkBindImageMemoryInfoKHR* = object

  VkBindImageMemoryDeviceGroupInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceIndexCount*: uint32
    pDeviceIndices*: ptr uint32
    splitInstanceBindRegionCount*: uint32
    pSplitInstanceBindRegions*: ptr VkRect2D

  VkBindImageMemoryDeviceGroupInfoKHR* = object

  VkDeviceGroupRenderPassBeginInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceMask*: uint32
    deviceRenderAreaCount*: uint32
    pDeviceRenderAreas*: ptr VkRect2D

  VkDeviceGroupRenderPassBeginInfoKHR* = object

  VkDeviceGroupCommandBufferBeginInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceMask*: uint32

  VkDeviceGroupCommandBufferBeginInfoKHR* = object

  VkDeviceGroupSubmitInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    waitSemaphoreCount*: uint32
    pWaitSemaphoreDeviceIndices*: ptr uint32
    commandBufferCount*: uint32
    pCommandBufferDeviceMasks*: ptr uint32
    signalSemaphoreCount*: uint32
    pSignalSemaphoreDeviceIndices*: ptr uint32

  VkDeviceGroupSubmitInfoKHR* = object

  VkDeviceGroupBindSparseInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    resourceDeviceIndex*: uint32
    memoryDeviceIndex*: uint32

  VkDeviceGroupBindSparseInfoKHR* = object

  VkDeviceGroupPresentCapabilitiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    presentMask*: array[VK_MAX_DEVICE_GROUP_SIZE, uint32]
    modes*: VkDeviceGroupPresentModeFlagsKHR

  VkImageSwapchainCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    swapchain*: VkSwapchainKHR

  VkBindImageMemorySwapchainInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    swapchain*: VkSwapchainKHR
    imageIndex*: uint32

  VkAcquireNextImageInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    swapchain*: VkSwapchainKHR
    timeout*: uint64
    semaphore*: VkSemaphore
    fence*: VkFence
    deviceMask*: uint32

  VkDeviceGroupPresentInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    swapchainCount*: uint32
    pDeviceMasks*: ptr uint32
    mode*: VkDeviceGroupPresentModeFlagBitsKHR

  VkDeviceGroupDeviceCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    physicalDeviceCount*: uint32
    pPhysicalDevices*: ptr VkPhysicalDevice

  VkDeviceGroupDeviceCreateInfoKHR* = object

  VkDeviceGroupSwapchainCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    modes*: VkDeviceGroupPresentModeFlagsKHR

  VkDescriptorUpdateTemplateEntry* = object
    dstBinding*: uint32
    dstArrayElement*: uint32
    descriptorCount*: uint32
    descriptorType*: VkDescriptorType
    offset*: uint
    stride*: uint

  VkDescriptorUpdateTemplateEntryKHR* = object

  VkDescriptorUpdateTemplateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDescriptorUpdateTemplateCreateFlags
    descriptorUpdateEntryCount*: uint32
    pDescriptorUpdateEntries*: ptr VkDescriptorUpdateTemplateEntry
    templateType*: VkDescriptorUpdateTemplateType
    descriptorSetLayout*: VkDescriptorSetLayout
    pipelineBindPoint*: VkPipelineBindPoint
    pipelineLayout*: VkPipelineLayout
    set*: uint32

  VkDescriptorUpdateTemplateCreateInfoKHR* = object

  VkXYColorEXT* = object
    x*: float32
    y*: float32

  VkHdrMetadataEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    displayPrimaryRed*: VkXYColorEXT
    displayPrimaryGreen*: VkXYColorEXT
    displayPrimaryBlue*: VkXYColorEXT
    whitePoint*: VkXYColorEXT
    maxLuminance*: float32
    minLuminance*: float32
    maxContentLightLevel*: float32
    maxFrameAverageLightLevel*: float32

  VkDisplayNativeHdrSurfaceCapabilitiesAMD* = object
    sType*: VkStructureType
    pNext*: pointer
    localDimmingSupport*: VkBool32

  VkSwapchainDisplayNativeHdrCreateInfoAMD* = object
    sType*: VkStructureType
    pNext*: pointer
    localDimmingEnable*: VkBool32

  VkRefreshCycleDurationGOOGLE* = object
    refreshDuration*: uint64

  VkPastPresentationTimingGOOGLE* = object
    presentID*: uint32
    desiredPresentTime*: uint64
    actualPresentTime*: uint64
    earliestPresentTime*: uint64
    presentMargin*: uint64

  VkPresentTimesInfoGOOGLE* = object
    sType*: VkStructureType
    pNext*: pointer
    swapchainCount*: uint32
    pTimes*: ptr VkPresentTimeGOOGLE

  VkPresentTimeGOOGLE* = object
    presentID*: uint32
    desiredPresentTime*: uint64

  VkIOSSurfaceCreateInfoMVK* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkIOSSurfaceCreateFlagsMVK
    pView*: pointer

  VkMacOSSurfaceCreateInfoMVK* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkMacOSSurfaceCreateFlagsMVK
    pView*: pointer

  VkMetalSurfaceCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkMetalSurfaceCreateFlagsEXT
    pLayer*: ptr CAMetalLayer

  VkViewportWScalingNV* = object
    xcoeff*: float32
    ycoeff*: float32

  VkPipelineViewportWScalingStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    viewportWScalingEnable*: VkBool32
    viewportCount*: uint32
    pViewportWScalings*: ptr VkViewportWScalingNV

  VkViewportSwizzleNV* = object
    x*: VkViewportCoordinateSwizzleNV
    y*: VkViewportCoordinateSwizzleNV
    z*: VkViewportCoordinateSwizzleNV
    w*: VkViewportCoordinateSwizzleNV

  VkPipelineViewportSwizzleStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineViewportSwizzleStateCreateFlagsNV
    viewportCount*: uint32
    pViewportSwizzles*: ptr VkViewportSwizzleNV

  VkPhysicalDeviceDiscardRectanglePropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    maxDiscardRectangles*: uint32

  VkPipelineDiscardRectangleStateCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineDiscardRectangleStateCreateFlagsEXT
    discardRectangleMode*: VkDiscardRectangleModeEXT
    discardRectangleCount*: uint32
    pDiscardRectangles*: ptr VkRect2D

  VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* = object
    sType*: VkStructureType
    pNext*: pointer
    perViewPositionAllComponents*: VkBool32

  VkInputAttachmentAspectReference* = object
    subpass*: uint32
    inputAttachmentIndex*: uint32
    aspectMask*: VkImageAspectFlags

  VkInputAttachmentAspectReferenceKHR* = object

  VkRenderPassInputAttachmentAspectCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    aspectReferenceCount*: uint32
    pAspectReferences*: ptr VkInputAttachmentAspectReference

  VkRenderPassInputAttachmentAspectCreateInfoKHR* = object

  VkPhysicalDeviceSurfaceInfo2KHR* = object
    sType*: VkStructureType
    pNext*: pointer
    surface*: VkSurfaceKHR

  VkSurfaceCapabilities2KHR* = object
    sType*: VkStructureType
    pNext*: pointer
    surfaceCapabilities*: VkSurfaceCapabilitiesKHR

  VkSurfaceFormat2KHR* = object
    sType*: VkStructureType
    pNext*: pointer
    surfaceFormat*: VkSurfaceFormatKHR

  VkDisplayProperties2KHR* = object
    sType*: VkStructureType
    pNext*: pointer
    displayProperties*: VkDisplayPropertiesKHR

  VkDisplayPlaneProperties2KHR* = object
    sType*: VkStructureType
    pNext*: pointer
    displayPlaneProperties*: VkDisplayPlanePropertiesKHR

  VkDisplayModeProperties2KHR* = object
    sType*: VkStructureType
    pNext*: pointer
    displayModeProperties*: VkDisplayModePropertiesKHR

  VkDisplayPlaneInfo2KHR* = object
    sType*: VkStructureType
    pNext*: pointer
    mode*: VkDisplayModeKHR
    planeIndex*: uint32

  VkDisplayPlaneCapabilities2KHR* = object
    sType*: VkStructureType
    pNext*: pointer
    capabilities*: VkDisplayPlaneCapabilitiesKHR

  VkSharedPresentSurfaceCapabilitiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    sharedPresentSupportedUsageFlags*: VkImageUsageFlags

  VkPhysicalDevice16BitStorageFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    storageBuffer16BitAccess*: VkBool32
    uniformAndStorageBuffer16BitAccess*: VkBool32
    storagePushConstant16*: VkBool32
    storageInputOutput16*: VkBool32

  VkPhysicalDevice16BitStorageFeaturesKHR* = object

  VkPhysicalDeviceSubgroupProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    subgroupSize*: uint32
    supportedStages*: VkShaderStageFlags
    supportedOperations*: VkSubgroupFeatureFlags
    quadOperationsInAllStages*: VkBool32

  VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderSubgroupExtendedTypes*: VkBool32

  VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR* = object

  VkBufferMemoryRequirementsInfo2* = object
    sType*: VkStructureType
    pNext*: pointer
    buffer*: VkBuffer

  VkBufferMemoryRequirementsInfo2KHR* = object

  VkImageMemoryRequirementsInfo2* = object
    sType*: VkStructureType
    pNext*: pointer
    image*: VkImage

  VkImageMemoryRequirementsInfo2KHR* = object

  VkImageSparseMemoryRequirementsInfo2* = object
    sType*: VkStructureType
    pNext*: pointer
    image*: VkImage

  VkImageSparseMemoryRequirementsInfo2KHR* = object

  VkMemoryRequirements2* = object
    sType*: VkStructureType
    pNext*: pointer
    memoryRequirements*: VkMemoryRequirements

  VkMemoryRequirements2KHR* = object

  VkSparseImageMemoryRequirements2* = object
    sType*: VkStructureType
    pNext*: pointer
    memoryRequirements*: VkSparseImageMemoryRequirements

  VkSparseImageMemoryRequirements2KHR* = object

  VkPhysicalDevicePointClippingProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    pointClippingBehavior*: VkPointClippingBehavior

  VkPhysicalDevicePointClippingPropertiesKHR* = object

  VkMemoryDedicatedRequirements* = object
    sType*: VkStructureType
    pNext*: pointer
    prefersDedicatedAllocation*: VkBool32
    requiresDedicatedAllocation*: VkBool32

  VkMemoryDedicatedRequirementsKHR* = object

  VkMemoryDedicatedAllocateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    image*: VkImage
    buffer*: VkBuffer

  VkMemoryDedicatedAllocateInfoKHR* = object

  VkImageViewUsageCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    usage*: VkImageUsageFlags

  VkImageViewUsageCreateInfoKHR* = object

  VkPipelineTessellationDomainOriginStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    domainOrigin*: VkTessellationDomainOrigin

  VkPipelineTessellationDomainOriginStateCreateInfoKHR* = object

  VkSamplerYcbcrConversionInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    conversion*: VkSamplerYcbcrConversion

  VkSamplerYcbcrConversionInfoKHR* = object

  VkSamplerYcbcrConversionCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    format*: VkFormat
    ycbcrModel*: VkSamplerYcbcrModelConversion
    ycbcrRange*: VkSamplerYcbcrRange
    components*: VkComponentMapping
    xChromaOffset*: VkChromaLocation
    yChromaOffset*: VkChromaLocation
    chromaFilter*: VkFilter
    forceExplicitReconstruction*: VkBool32

  VkSamplerYcbcrConversionCreateInfoKHR* = object

  VkBindImagePlaneMemoryInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    planeAspect*: VkImageAspectFlagBits

  VkBindImagePlaneMemoryInfoKHR* = object

  VkImagePlaneMemoryRequirementsInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    planeAspect*: VkImageAspectFlagBits

  VkImagePlaneMemoryRequirementsInfoKHR* = object

  VkPhysicalDeviceSamplerYcbcrConversionFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    samplerYcbcrConversion*: VkBool32

  VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR* = object

  VkSamplerYcbcrConversionImageFormatProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    combinedImageSamplerDescriptorCount*: uint32

  VkSamplerYcbcrConversionImageFormatPropertiesKHR* = object

  VkTextureLODGatherFormatPropertiesAMD* = object
    sType*: VkStructureType
    pNext*: pointer
    supportsTextureGatherLODBiasAMD*: VkBool32

  VkConditionalRenderingBeginInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    buffer*: VkBuffer
    offset*: VkDeviceSize
    flags*: VkConditionalRenderingFlagsEXT

  VkProtectedSubmitInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    protectedSubmit*: VkBool32

  VkPhysicalDeviceProtectedMemoryFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    protectedMemory*: VkBool32

  VkPhysicalDeviceProtectedMemoryProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    protectedNoFault*: VkBool32

  VkDeviceQueueInfo2* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDeviceQueueCreateFlags
    queueFamilyIndex*: uint32
    queueIndex*: uint32

  VkPipelineCoverageToColorStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineCoverageToColorStateCreateFlagsNV
    coverageToColorEnable*: VkBool32
    coverageToColorLocation*: uint32

  VkPhysicalDeviceSamplerFilterMinmaxProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    filterMinmaxSingleComponentFormats*: VkBool32
    filterMinmaxImageComponentMapping*: VkBool32

  VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* = object

  VkSampleLocationEXT* = object
    x*: float32
    y*: float32

  VkSampleLocationsInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    sampleLocationsPerPixel*: VkSampleCountFlagBits
    sampleLocationGridSize*: VkExtent2D
    sampleLocationsCount*: uint32
    pSampleLocations*: ptr VkSampleLocationEXT

  VkAttachmentSampleLocationsEXT* = object
    attachmentIndex*: uint32
    sampleLocationsInfo*: VkSampleLocationsInfoEXT

  VkSubpassSampleLocationsEXT* = object
    subpassIndex*: uint32
    sampleLocationsInfo*: VkSampleLocationsInfoEXT

  VkRenderPassSampleLocationsBeginInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    attachmentInitialSampleLocationsCount*: uint32
    pAttachmentInitialSampleLocations*: ptr VkAttachmentSampleLocationsEXT
    postSubpassSampleLocationsCount*: uint32
    pPostSubpassSampleLocations*: ptr VkSubpassSampleLocationsEXT

  VkPipelineSampleLocationsStateCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    sampleLocationsEnable*: VkBool32
    sampleLocationsInfo*: VkSampleLocationsInfoEXT

  VkPhysicalDeviceSampleLocationsPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    sampleLocationSampleCounts*: VkSampleCountFlags
    maxSampleLocationGridSize*: VkExtent2D
    sampleLocationCoordinateRange*: array[2, float32]
    sampleLocationSubPixelBits*: uint32
    variableSampleLocations*: VkBool32

  VkMultisamplePropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    maxSampleLocationGridSize*: VkExtent2D

  VkSamplerReductionModeCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    reductionMode*: VkSamplerReductionMode

  VkSamplerReductionModeCreateInfoEXT* = object

  VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    advancedBlendCoherentOperations*: VkBool32

  VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    advancedBlendMaxColorAttachments*: uint32
    advancedBlendIndependentBlend*: VkBool32
    advancedBlendNonPremultipliedSrcColor*: VkBool32
    advancedBlendNonPremultipliedDstColor*: VkBool32
    advancedBlendCorrelatedOverlap*: VkBool32
    advancedBlendAllOperations*: VkBool32

  VkPipelineColorBlendAdvancedStateCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    srcPremultiplied*: VkBool32
    dstPremultiplied*: VkBool32
    blendOverlap*: VkBlendOverlapEXT

  VkPhysicalDeviceInlineUniformBlockFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    inlineUniformBlock*: VkBool32
    descriptorBindingInlineUniformBlockUpdateAfterBind*: VkBool32

  VkPhysicalDeviceInlineUniformBlockPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    maxInlineUniformBlockSize*: uint32
    maxPerStageDescriptorInlineUniformBlocks*: uint32
    maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks*: uint32
    maxDescriptorSetInlineUniformBlocks*: uint32
    maxDescriptorSetUpdateAfterBindInlineUniformBlocks*: uint32

  VkWriteDescriptorSetInlineUniformBlockEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    dataSize*: uint32
    pData*: pointer

  VkDescriptorPoolInlineUniformBlockCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    maxInlineUniformBlockBindings*: uint32

  VkPipelineCoverageModulationStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineCoverageModulationStateCreateFlagsNV
    coverageModulationMode*: VkCoverageModulationModeNV
    coverageModulationTableEnable*: VkBool32
    coverageModulationTableCount*: uint32
    pCoverageModulationTable*: ptr float32

  VkImageFormatListCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    viewFormatCount*: uint32
    pViewFormats*: ptr VkFormat

  VkImageFormatListCreateInfoKHR* = object

  VkValidationCacheCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkValidationCacheCreateFlagsEXT
    initialDataSize*: uint
    pInitialData*: pointer

  VkShaderModuleValidationCacheCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    validationCache*: VkValidationCacheEXT

  VkPhysicalDeviceMaintenance3Properties* = object
    sType*: VkStructureType
    pNext*: pointer
    maxPerSetDescriptors*: uint32
    maxMemoryAllocationSize*: VkDeviceSize

  VkPhysicalDeviceMaintenance3PropertiesKHR* = object

  VkDescriptorSetLayoutSupport* = object
    sType*: VkStructureType
    pNext*: pointer
    supported*: VkBool32

  VkDescriptorSetLayoutSupportKHR* = object

  VkPhysicalDeviceShaderDrawParametersFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderDrawParameters*: VkBool32

  VkPhysicalDeviceShaderDrawParameterFeatures* = object

  VkPhysicalDeviceShaderFloat16Int8Features* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderFloat16*: VkBool32
    shaderInt8*: VkBool32

  VkPhysicalDeviceShaderFloat16Int8FeaturesKHR* = object

  VkPhysicalDeviceFloat16Int8FeaturesKHR* = object

  VkPhysicalDeviceFloatControlsProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    denormBehaviorIndependence*: VkShaderFloatControlsIndependence
    roundingModeIndependence*: VkShaderFloatControlsIndependence
    shaderSignedZeroInfNanPreserveFloat16*: VkBool32
    shaderSignedZeroInfNanPreserveFloat32*: VkBool32
    shaderSignedZeroInfNanPreserveFloat64*: VkBool32
    shaderDenormPreserveFloat16*: VkBool32
    shaderDenormPreserveFloat32*: VkBool32
    shaderDenormPreserveFloat64*: VkBool32
    shaderDenormFlushToZeroFloat16*: VkBool32
    shaderDenormFlushToZeroFloat32*: VkBool32
    shaderDenormFlushToZeroFloat64*: VkBool32
    shaderRoundingModeRTEFloat16*: VkBool32
    shaderRoundingModeRTEFloat32*: VkBool32
    shaderRoundingModeRTEFloat64*: VkBool32
    shaderRoundingModeRTZFloat16*: VkBool32
    shaderRoundingModeRTZFloat32*: VkBool32
    shaderRoundingModeRTZFloat64*: VkBool32

  VkPhysicalDeviceFloatControlsPropertiesKHR* = object

  VkPhysicalDeviceHostQueryResetFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    hostQueryReset*: VkBool32

  VkPhysicalDeviceHostQueryResetFeaturesEXT* = object

  VkNativeBufferUsage2ANDROID* = object
    consumer*: uint64
    producer*: uint64

  VkNativeBufferANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    handle*: pointer
    stride*: int
    format*: int
    usage*: int
    usage2*: VkNativeBufferUsage2ANDROID

  VkSwapchainImageCreateInfoANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    usage*: VkSwapchainImageUsageFlagsANDROID

  VkPhysicalDevicePresentationPropertiesANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    sharedImage*: VkBool32

  VkShaderResourceUsageAMD* = object
    numUsedVgprs*: uint32
    numUsedSgprs*: uint32
    ldsSizePerLocalWorkGroup*: uint32
    ldsUsageSizeInBytes*: uint
    scratchMemUsageInBytes*: uint

  VkShaderStatisticsInfoAMD* = object
    shaderStageMask*: VkShaderStageFlags
    resourceUsage*: VkShaderResourceUsageAMD
    numPhysicalVgprs*: uint32
    numPhysicalSgprs*: uint32
    numAvailableVgprs*: uint32
    numAvailableSgprs*: uint32
    computeWorkGroupSize*: array[3, uint32]

  VkDeviceQueueGlobalPriorityCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    globalPriority*: VkQueueGlobalPriorityEXT

  VkDebugUtilsObjectNameInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    objectType*: VkObjectType
    objectHandle*: uint64
    pObjectName*: cstring

  VkDebugUtilsObjectTagInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    objectType*: VkObjectType
    objectHandle*: uint64
    tagName*: uint64
    tagSize*: uint
    pTag*: pointer

  VkDebugUtilsLabelEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    pLabelName*: cstring
    color*: array[4, float32]

  VkDebugUtilsMessengerCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDebugUtilsMessengerCreateFlagsEXT
    messageSeverity*: VkDebugUtilsMessageSeverityFlagsEXT
    messageType*: VkDebugUtilsMessageTypeFlagsEXT
    pfnUserCallback*: PFN_vkDebugUtilsMessengerCallbackEXT
    pUserData*: pointer

  VkDebugUtilsMessengerCallbackDataEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDebugUtilsMessengerCallbackDataFlagsEXT
    pMessageIdName*: cstring
    messageIdNumber*: int32
    pMessage*: cstring
    queueLabelCount*: uint32
    pQueueLabels*: ptr VkDebugUtilsLabelEXT
    cmdBufLabelCount*: uint32
    pCmdBufLabels*: ptr VkDebugUtilsLabelEXT
    objectCount*: uint32
    pObjects*: ptr VkDebugUtilsObjectNameInfoEXT

  VkImportMemoryHostPointerInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    handleType*: VkExternalMemoryHandleTypeFlagBits
    pHostPointer*: pointer

  VkMemoryHostPointerPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    memoryTypeBits*: uint32

  VkPhysicalDeviceExternalMemoryHostPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    minImportedHostPointerAlignment*: VkDeviceSize

  VkPhysicalDeviceConservativeRasterizationPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    primitiveOverestimationSize*: float32
    maxExtraPrimitiveOverestimationSize*: float32
    extraPrimitiveOverestimationSizeGranularity*: float32
    primitiveUnderestimation*: VkBool32
    conservativePointAndLineRasterization*: VkBool32
    degenerateTrianglesRasterized*: VkBool32
    degenerateLinesRasterized*: VkBool32
    fullyCoveredFragmentShaderInputVariable*: VkBool32
    conservativeRasterizationPostDepthCoverage*: VkBool32

  VkCalibratedTimestampInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    timeDomain*: VkTimeDomainEXT

  VkPhysicalDeviceShaderCorePropertiesAMD* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderEngineCount*: uint32
    shaderArraysPerEngineCount*: uint32
    computeUnitsPerShaderArray*: uint32
    simdPerComputeUnit*: uint32
    wavefrontsPerSimd*: uint32
    wavefrontSize*: uint32
    sgprsPerSimd*: uint32
    minSgprAllocation*: uint32
    maxSgprAllocation*: uint32
    sgprAllocationGranularity*: uint32
    vgprsPerSimd*: uint32
    minVgprAllocation*: uint32
    maxVgprAllocation*: uint32
    vgprAllocationGranularity*: uint32

  VkPhysicalDeviceShaderCoreProperties2AMD* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderCoreFeatures*: VkShaderCorePropertiesFlagsAMD
    activeComputeUnitCount*: uint32

  VkPipelineRasterizationConservativeStateCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineRasterizationConservativeStateCreateFlagsEXT
    conservativeRasterizationMode*: VkConservativeRasterizationModeEXT
    extraPrimitiveOverestimationSize*: float32

  VkPhysicalDeviceDescriptorIndexingFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    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*: VkBool32

  VkPhysicalDeviceDescriptorIndexingFeaturesEXT* = object

  VkPhysicalDeviceDescriptorIndexingProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    maxUpdateAfterBindDescriptorsInAllPools*: uint32
    shaderUniformBufferArrayNonUniformIndexingNative*: VkBool32
    shaderSampledImageArrayNonUniformIndexingNative*: VkBool32
    shaderStorageBufferArrayNonUniformIndexingNative*: VkBool32
    shaderStorageImageArrayNonUniformIndexingNative*: VkBool32
    shaderInputAttachmentArrayNonUniformIndexingNative*: VkBool32
    robustBufferAccessUpdateAfterBind*: VkBool32
    quadDivergentImplicitLod*: VkBool32
    maxPerStageDescriptorUpdateAfterBindSamplers*: uint32
    maxPerStageDescriptorUpdateAfterBindUniformBuffers*: uint32
    maxPerStageDescriptorUpdateAfterBindStorageBuffers*: uint32
    maxPerStageDescriptorUpdateAfterBindSampledImages*: uint32
    maxPerStageDescriptorUpdateAfterBindStorageImages*: uint32
    maxPerStageDescriptorUpdateAfterBindInputAttachments*: uint32
    maxPerStageUpdateAfterBindResources*: uint32
    maxDescriptorSetUpdateAfterBindSamplers*: uint32
    maxDescriptorSetUpdateAfterBindUniformBuffers*: uint32
    maxDescriptorSetUpdateAfterBindUniformBuffersDynamic*: uint32
    maxDescriptorSetUpdateAfterBindStorageBuffers*: uint32
    maxDescriptorSetUpdateAfterBindStorageBuffersDynamic*: uint32
    maxDescriptorSetUpdateAfterBindSampledImages*: uint32
    maxDescriptorSetUpdateAfterBindStorageImages*: uint32
    maxDescriptorSetUpdateAfterBindInputAttachments*: uint32

  VkPhysicalDeviceDescriptorIndexingPropertiesEXT* = object

  VkDescriptorSetLayoutBindingFlagsCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    bindingCount*: uint32
    pBindingFlags*: ptr VkDescriptorBindingFlags

  VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* = object

  VkDescriptorSetVariableDescriptorCountAllocateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    descriptorSetCount*: uint32
    pDescriptorCounts*: ptr uint32

  VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* = object

  VkDescriptorSetVariableDescriptorCountLayoutSupport* = object
    sType*: VkStructureType
    pNext*: pointer
    maxVariableDescriptorCount*: uint32

  VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* = object

  VkAttachmentDescription2* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkAttachmentDescriptionFlags
    format*: VkFormat
    samples*: VkSampleCountFlagBits
    loadOp*: VkAttachmentLoadOp
    storeOp*: VkAttachmentStoreOp
    stencilLoadOp*: VkAttachmentLoadOp
    stencilStoreOp*: VkAttachmentStoreOp
    initialLayout*: VkImageLayout
    finalLayout*: VkImageLayout

  VkAttachmentDescription2KHR* = object

  VkAttachmentReference2* = object
    sType*: VkStructureType
    pNext*: pointer
    attachment*: uint32
    layout*: VkImageLayout
    aspectMask*: VkImageAspectFlags

  VkAttachmentReference2KHR* = object

  VkSubpassDescription2* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkSubpassDescriptionFlags
    pipelineBindPoint*: VkPipelineBindPoint
    viewMask*: uint32
    inputAttachmentCount*: uint32
    pInputAttachments*: ptr VkAttachmentReference2
    colorAttachmentCount*: uint32
    pColorAttachments*: ptr VkAttachmentReference2
    pResolveAttachments*: ptr VkAttachmentReference2
    pDepthStencilAttachment*: ptr VkAttachmentReference2
    preserveAttachmentCount*: uint32
    pPreserveAttachments*: ptr uint32

  VkSubpassDescription2KHR* = object

  VkSubpassDependency2* = object
    sType*: VkStructureType
    pNext*: pointer
    srcSubpass*: uint32
    dstSubpass*: uint32
    srcStageMask*: VkPipelineStageFlags
    dstStageMask*: VkPipelineStageFlags
    srcAccessMask*: VkAccessFlags
    dstAccessMask*: VkAccessFlags
    dependencyFlags*: VkDependencyFlags
    viewOffset*: int32

  VkSubpassDependency2KHR* = object

  VkRenderPassCreateInfo2* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkRenderPassCreateFlags
    attachmentCount*: uint32
    pAttachments*: ptr VkAttachmentDescription2
    subpassCount*: uint32
    pSubpasses*: ptr VkSubpassDescription2
    dependencyCount*: uint32
    pDependencies*: ptr VkSubpassDependency2
    correlatedViewMaskCount*: uint32
    pCorrelatedViewMasks*: ptr uint32

  VkRenderPassCreateInfo2KHR* = object

  VkSubpassBeginInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    contents*: VkSubpassContents

  VkSubpassBeginInfoKHR* = object

  VkSubpassEndInfo* = object
    sType*: VkStructureType
    pNext*: pointer

  VkSubpassEndInfoKHR* = object

  VkPhysicalDeviceTimelineSemaphoreFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    timelineSemaphore*: VkBool32

  VkPhysicalDeviceTimelineSemaphoreFeaturesKHR* = object

  VkPhysicalDeviceTimelineSemaphoreProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    maxTimelineSemaphoreValueDifference*: uint64

  VkPhysicalDeviceTimelineSemaphorePropertiesKHR* = object

  VkSemaphoreTypeCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    semaphoreType*: VkSemaphoreType
    initialValue*: uint64

  VkSemaphoreTypeCreateInfoKHR* = object

  VkTimelineSemaphoreSubmitInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    waitSemaphoreValueCount*: uint32
    pWaitSemaphoreValues*: ptr uint64
    signalSemaphoreValueCount*: uint32
    pSignalSemaphoreValues*: ptr uint64

  VkTimelineSemaphoreSubmitInfoKHR* = object

  VkSemaphoreWaitInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkSemaphoreWaitFlags
    semaphoreCount*: uint32
    pSemaphores*: ptr VkSemaphore
    pValues*: ptr uint64

  VkSemaphoreWaitInfoKHR* = object

  VkSemaphoreSignalInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    semaphore*: VkSemaphore
    value*: uint64

  VkSemaphoreSignalInfoKHR* = object

  VkVertexInputBindingDivisorDescriptionEXT* = object
    binding*: uint32
    divisor*: uint32

  VkPipelineVertexInputDivisorStateCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    vertexBindingDivisorCount*: uint32
    pVertexBindingDivisors*: ptr VkVertexInputBindingDivisorDescriptionEXT

  VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    maxVertexAttribDivisor*: uint32

  VkPhysicalDevicePCIBusInfoPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    pciDomain*: uint32
    pciBus*: uint32
    pciDevice*: uint32
    pciFunction*: uint32

  VkImportAndroidHardwareBufferInfoANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    buffer*: ptr AHardwareBuffer

  VkAndroidHardwareBufferUsageANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    androidHardwareBufferUsage*: uint64

  VkAndroidHardwareBufferPropertiesANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    allocationSize*: VkDeviceSize
    memoryTypeBits*: uint32

  VkMemoryGetAndroidHardwareBufferInfoANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    memory*: VkDeviceMemory

  VkAndroidHardwareBufferFormatPropertiesANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    format*: VkFormat
    externalFormat*: uint64
    formatFeatures*: VkFormatFeatureFlags
    samplerYcbcrConversionComponents*: VkComponentMapping
    suggestedYcbcrModel*: VkSamplerYcbcrModelConversion
    suggestedYcbcrRange*: VkSamplerYcbcrRange
    suggestedXChromaOffset*: VkChromaLocation
    suggestedYChromaOffset*: VkChromaLocation

  VkCommandBufferInheritanceConditionalRenderingInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    conditionalRenderingEnable*: VkBool32

  VkExternalFormatANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    externalFormat*: uint64

  VkPhysicalDevice8BitStorageFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    storageBuffer8BitAccess*: VkBool32
    uniformAndStorageBuffer8BitAccess*: VkBool32
    storagePushConstant8*: VkBool32

  VkPhysicalDevice8BitStorageFeaturesKHR* = object

  VkPhysicalDeviceConditionalRenderingFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    conditionalRendering*: VkBool32
    inheritedConditionalRendering*: VkBool32

  VkPhysicalDeviceVulkanMemoryModelFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    vulkanMemoryModel*: VkBool32
    vulkanMemoryModelDeviceScope*: VkBool32
    vulkanMemoryModelAvailabilityVisibilityChains*: VkBool32

  VkPhysicalDeviceVulkanMemoryModelFeaturesKHR* = object

  VkPhysicalDeviceShaderAtomicInt64Features* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderBufferInt64Atomics*: VkBool32
    shaderSharedInt64Atomics*: VkBool32

  VkPhysicalDeviceShaderAtomicInt64FeaturesKHR* = object

  VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderBufferFloat32Atomics*: VkBool32
    shaderBufferFloat32AtomicAdd*: VkBool32
    shaderBufferFloat64Atomics*: VkBool32
    shaderBufferFloat64AtomicAdd*: VkBool32
    shaderSharedFloat32Atomics*: VkBool32
    shaderSharedFloat32AtomicAdd*: VkBool32
    shaderSharedFloat64Atomics*: VkBool32
    shaderSharedFloat64AtomicAdd*: VkBool32
    shaderImageFloat32Atomics*: VkBool32
    shaderImageFloat32AtomicAdd*: VkBool32
    sparseImageFloat32Atomics*: VkBool32
    sparseImageFloat32AtomicAdd*: VkBool32

  VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    vertexAttributeInstanceRateDivisor*: VkBool32
    vertexAttributeInstanceRateZeroDivisor*: VkBool32

  VkQueueFamilyCheckpointPropertiesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    checkpointExecutionStageMask*: VkPipelineStageFlags

  VkCheckpointDataNV* = object
    sType*: VkStructureType
    pNext*: pointer
    stage*: VkPipelineStageFlagBits
    pCheckpointMarker*: pointer

  VkPhysicalDeviceDepthStencilResolveProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    supportedDepthResolveModes*: VkResolveModeFlags
    supportedStencilResolveModes*: VkResolveModeFlags
    independentResolveNone*: VkBool32
    independentResolve*: VkBool32

  VkPhysicalDeviceDepthStencilResolvePropertiesKHR* = object

  VkSubpassDescriptionDepthStencilResolve* = object
    sType*: VkStructureType
    pNext*: pointer
    depthResolveMode*: VkResolveModeFlagBits
    stencilResolveMode*: VkResolveModeFlagBits
    pDepthStencilResolveAttachment*: ptr VkAttachmentReference2

  VkSubpassDescriptionDepthStencilResolveKHR* = object

  VkImageViewASTCDecodeModeEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    decodeMode*: VkFormat

  VkPhysicalDeviceASTCDecodeFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    decodeModeSharedExponent*: VkBool32

  VkPhysicalDeviceTransformFeedbackFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    transformFeedback*: VkBool32
    geometryStreams*: VkBool32

  VkPhysicalDeviceTransformFeedbackPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    maxTransformFeedbackStreams*: uint32
    maxTransformFeedbackBuffers*: uint32
    maxTransformFeedbackBufferSize*: VkDeviceSize
    maxTransformFeedbackStreamDataSize*: uint32
    maxTransformFeedbackBufferDataSize*: uint32
    maxTransformFeedbackBufferDataStride*: uint32
    transformFeedbackQueries*: VkBool32
    transformFeedbackStreamsLinesTriangles*: VkBool32
    transformFeedbackRasterizationStreamSelect*: VkBool32
    transformFeedbackDraw*: VkBool32

  VkPipelineRasterizationStateStreamCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineRasterizationStateStreamCreateFlagsEXT
    rasterizationStream*: uint32

  VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    representativeFragmentTest*: VkBool32

  VkPipelineRepresentativeFragmentTestStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    representativeFragmentTestEnable*: VkBool32

  VkPhysicalDeviceExclusiveScissorFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    exclusiveScissor*: VkBool32

  VkPipelineViewportExclusiveScissorStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    exclusiveScissorCount*: uint32
    pExclusiveScissors*: ptr VkRect2D

  VkPhysicalDeviceCornerSampledImageFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    cornerSampledImage*: VkBool32

  VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    computeDerivativeGroupQuads*: VkBool32
    computeDerivativeGroupLinear*: VkBool32

  VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    fragmentShaderBarycentric*: VkBool32

  VkPhysicalDeviceShaderImageFootprintFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    imageFootprint*: VkBool32

  VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    dedicatedAllocationImageAliasing*: VkBool32

  VkShadingRatePaletteNV* = object
    shadingRatePaletteEntryCount*: uint32
    pShadingRatePaletteEntries*: ptr VkShadingRatePaletteEntryNV

  VkPipelineViewportShadingRateImageStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    shadingRateImageEnable*: VkBool32
    viewportCount*: uint32
    pShadingRatePalettes*: ptr VkShadingRatePaletteNV

  VkPhysicalDeviceShadingRateImageFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    shadingRateImage*: VkBool32
    shadingRateCoarseSampleOrder*: VkBool32

  VkPhysicalDeviceShadingRateImagePropertiesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    shadingRateTexelSize*: VkExtent2D
    shadingRatePaletteSize*: uint32
    shadingRateMaxCoarseSamples*: uint32

  VkCoarseSampleLocationNV* = object
    pixelX*: uint32
    pixelY*: uint32
    sample*: uint32

  VkCoarseSampleOrderCustomNV* = object
    shadingRate*: VkShadingRatePaletteEntryNV
    sampleCount*: uint32
    sampleLocationCount*: uint32
    pSampleLocations*: ptr VkCoarseSampleLocationNV

  VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    sampleOrderType*: VkCoarseSampleOrderTypeNV
    customSampleOrderCount*: uint32
    pCustomSampleOrders*: ptr VkCoarseSampleOrderCustomNV

  VkPhysicalDeviceMeshShaderFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    taskShader*: VkBool32
    meshShader*: VkBool32

  VkPhysicalDeviceMeshShaderPropertiesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    maxDrawMeshTasksCount*: uint32
    maxTaskWorkGroupInvocations*: uint32
    maxTaskWorkGroupSize*: array[3, uint32]
    maxTaskTotalMemorySize*: uint32
    maxTaskOutputCount*: uint32
    maxMeshWorkGroupInvocations*: uint32
    maxMeshWorkGroupSize*: array[3, uint32]
    maxMeshTotalMemorySize*: uint32
    maxMeshOutputVertices*: uint32
    maxMeshOutputPrimitives*: uint32
    maxMeshMultiviewViewCount*: uint32
    meshOutputPerVertexGranularity*: uint32
    meshOutputPerPrimitiveGranularity*: uint32

  VkDrawMeshTasksIndirectCommandNV* = object
    taskCount*: uint32
    firstTask*: uint32

  VkRayTracingShaderGroupCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    `type`*: VkRayTracingShaderGroupTypeKHR
    generalShader*: uint32
    closestHitShader*: uint32
    anyHitShader*: uint32
    intersectionShader*: uint32

  VkRayTracingShaderGroupCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    `type`*: VkRayTracingShaderGroupTypeKHR
    generalShader*: uint32
    closestHitShader*: uint32
    anyHitShader*: uint32
    intersectionShader*: uint32
    pShaderGroupCaptureReplayHandle*: pointer

  VkRayTracingPipelineCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineCreateFlags
    stageCount*: uint32
    pStages*: ptr VkPipelineShaderStageCreateInfo
    groupCount*: uint32
    pGroups*: ptr VkRayTracingShaderGroupCreateInfoNV
    maxRecursionDepth*: uint32
    layout*: VkPipelineLayout
    basePipelineHandle*: VkPipeline
    basePipelineIndex*: int32

  VkRayTracingPipelineCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineCreateFlags
    stageCount*: uint32
    pStages*: ptr VkPipelineShaderStageCreateInfo
    groupCount*: uint32
    pGroups*: ptr VkRayTracingShaderGroupCreateInfoKHR
    maxRecursionDepth*: uint32
    libraries*: VkPipelineLibraryCreateInfoKHR
    pLibraryInterface*: ptr VkRayTracingPipelineInterfaceCreateInfoKHR
    layout*: VkPipelineLayout
    basePipelineHandle*: VkPipeline
    basePipelineIndex*: int32

  VkGeometryTrianglesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    vertexData*: VkBuffer
    vertexOffset*: VkDeviceSize
    vertexCount*: uint32
    vertexStride*: VkDeviceSize
    vertexFormat*: VkFormat
    indexData*: VkBuffer
    indexOffset*: VkDeviceSize
    indexCount*: uint32
    indexType*: VkIndexType
    transformData*: VkBuffer
    transformOffset*: VkDeviceSize

  VkGeometryAABBNV* = object
    sType*: VkStructureType
    pNext*: pointer
    aabbData*: VkBuffer
    numAABBs*: uint32
    stride*: uint32
    offset*: VkDeviceSize

  VkGeometryDataNV* = object
    triangles*: VkGeometryTrianglesNV
    aabbs*: VkGeometryAABBNV

  VkGeometryNV* = object
    sType*: VkStructureType
    pNext*: pointer
    geometryType*: VkGeometryTypeKHR
    geometry*: VkGeometryDataNV
    flags*: VkGeometryFlagsKHR

  VkAccelerationStructureInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    `type`*: VkAccelerationStructureTypeNV
    flags*: VkBuildAccelerationStructureFlagsNV
    instanceCount*: uint32
    geometryCount*: uint32
    pGeometries*: ptr VkGeometryNV

  VkAccelerationStructureCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    compactedSize*: VkDeviceSize
    info*: VkAccelerationStructureInfoNV

  VkBindAccelerationStructureMemoryInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    accelerationStructure*: VkAccelerationStructureKHR
    memory*: VkDeviceMemory
    memoryOffset*: VkDeviceSize
    deviceIndexCount*: uint32
    pDeviceIndices*: ptr uint32

  VkBindAccelerationStructureMemoryInfoNV* = object

  VkWriteDescriptorSetAccelerationStructureKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    accelerationStructureCount*: uint32
    pAccelerationStructures*: ptr VkAccelerationStructureKHR

  VkWriteDescriptorSetAccelerationStructureNV* = object

  VkAccelerationStructureMemoryRequirementsInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    `type`*: VkAccelerationStructureMemoryRequirementsTypeKHR
    buildType*: VkAccelerationStructureBuildTypeKHR
    accelerationStructure*: VkAccelerationStructureKHR

  VkAccelerationStructureMemoryRequirementsInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    `type`*: VkAccelerationStructureMemoryRequirementsTypeNV
    accelerationStructure*: VkAccelerationStructureNV

  VkPhysicalDeviceRayTracingFeaturesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    rayTracing*: VkBool32
    rayTracingShaderGroupHandleCaptureReplay*: VkBool32
    rayTracingShaderGroupHandleCaptureReplayMixed*: VkBool32
    rayTracingAccelerationStructureCaptureReplay*: VkBool32
    rayTracingIndirectTraceRays*: VkBool32
    rayTracingIndirectAccelerationStructureBuild*: VkBool32
    rayTracingHostAccelerationStructureCommands*: VkBool32
    rayQuery*: VkBool32
    rayTracingPrimitiveCulling*: VkBool32

  VkPhysicalDeviceRayTracingPropertiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderGroupHandleSize*: uint32
    maxRecursionDepth*: uint32
    maxShaderGroupStride*: uint32
    shaderGroupBaseAlignment*: uint32
    maxGeometryCount*: uint64
    maxInstanceCount*: uint64
    maxPrimitiveCount*: uint64
    maxDescriptorSetAccelerationStructures*: uint32
    shaderGroupHandleCaptureReplaySize*: uint32

  VkPhysicalDeviceRayTracingPropertiesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderGroupHandleSize*: uint32
    maxRecursionDepth*: uint32
    maxShaderGroupStride*: uint32
    shaderGroupBaseAlignment*: uint32
    maxGeometryCount*: uint64
    maxInstanceCount*: uint64
    maxTriangleCount*: uint64
    maxDescriptorSetAccelerationStructures*: uint32

  VkStridedBufferRegionKHR* = object
    buffer*: VkBuffer
    offset*: VkDeviceSize
    stride*: VkDeviceSize
    size*: VkDeviceSize

  VkTraceRaysIndirectCommandKHR* = object
    width*: uint32
    height*: uint32
    depth*: uint32

  VkDrmFormatModifierPropertiesListEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    drmFormatModifierCount*: uint32
    pDrmFormatModifierProperties*: ptr VkDrmFormatModifierPropertiesEXT

  VkDrmFormatModifierPropertiesEXT* = object
    drmFormatModifier*: uint64
    drmFormatModifierPlaneCount*: uint32
    drmFormatModifierTilingFeatures*: VkFormatFeatureFlags

  VkPhysicalDeviceImageDrmFormatModifierInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    drmFormatModifier*: uint64
    sharingMode*: VkSharingMode
    queueFamilyIndexCount*: uint32
    pQueueFamilyIndices*: ptr uint32

  VkImageDrmFormatModifierListCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    drmFormatModifierCount*: uint32
    pDrmFormatModifiers*: ptr uint64

  VkImageDrmFormatModifierExplicitCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    drmFormatModifier*: uint64
    drmFormatModifierPlaneCount*: uint32
    pPlaneLayouts*: ptr VkSubresourceLayout

  VkImageDrmFormatModifierPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    drmFormatModifier*: uint64

  VkImageStencilUsageCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    stencilUsage*: VkImageUsageFlags

  VkImageStencilUsageCreateInfoEXT* = object

  VkDeviceMemoryOverallocationCreateInfoAMD* = object
    sType*: VkStructureType
    pNext*: pointer
    overallocationBehavior*: VkMemoryOverallocationBehaviorAMD

  VkPhysicalDeviceFragmentDensityMapFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    fragmentDensityMap*: VkBool32
    fragmentDensityMapDynamic*: VkBool32
    fragmentDensityMapNonSubsampledImages*: VkBool32

  VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    fragmentDensityMapDeferred*: VkBool32

  VkPhysicalDeviceFragmentDensityMapPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    minFragmentDensityTexelSize*: VkExtent2D
    maxFragmentDensityTexelSize*: VkExtent2D
    fragmentDensityInvocations*: VkBool32

  VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    subsampledLoads*: VkBool32
    subsampledCoarseReconstructionEarlyAccess*: VkBool32
    maxSubsampledArrayLayers*: uint32
    maxDescriptorSetSubsampledSamplers*: uint32

  VkRenderPassFragmentDensityMapCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    fragmentDensityMapAttachment*: VkAttachmentReference

  VkPhysicalDeviceScalarBlockLayoutFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    scalarBlockLayout*: VkBool32

  VkPhysicalDeviceScalarBlockLayoutFeaturesEXT* = object

  VkSurfaceProtectedCapabilitiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    supportsProtected*: VkBool32

  VkPhysicalDeviceUniformBufferStandardLayoutFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    uniformBufferStandardLayout*: VkBool32

  VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR* = object

  VkPhysicalDeviceDepthClipEnableFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    depthClipEnable*: VkBool32

  VkPipelineRasterizationDepthClipStateCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    depthClipEnable*: VkBool32

  VkPhysicalDeviceMemoryBudgetPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    heapBudget*: array[VK_MAX_MEMORY_HEAPS, VkDeviceSize]
    heapUsage*: array[VK_MAX_MEMORY_HEAPS, VkDeviceSize]

  VkPhysicalDeviceMemoryPriorityFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    memoryPriority*: VkBool32

  VkMemoryPriorityAllocateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    priority*: float32

  VkPhysicalDeviceBufferDeviceAddressFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    bufferDeviceAddress*: VkBool32
    bufferDeviceAddressCaptureReplay*: VkBool32
    bufferDeviceAddressMultiDevice*: VkBool32

  VkPhysicalDeviceBufferDeviceAddressFeaturesKHR* = object

  VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    bufferDeviceAddress*: VkBool32
    bufferDeviceAddressCaptureReplay*: VkBool32
    bufferDeviceAddressMultiDevice*: VkBool32

  VkPhysicalDeviceBufferAddressFeaturesEXT* = object

  VkBufferDeviceAddressInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    buffer*: VkBuffer

  VkBufferDeviceAddressInfoKHR* = object

  VkBufferDeviceAddressInfoEXT* = object

  VkBufferOpaqueCaptureAddressCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    opaqueCaptureAddress*: uint64

  VkBufferOpaqueCaptureAddressCreateInfoKHR* = object

  VkBufferDeviceAddressCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceAddress*: VkDeviceAddress

  VkPhysicalDeviceImageViewImageFormatInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    imageViewType*: VkImageViewType

  VkFilterCubicImageViewImageFormatPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    filterCubic*: VkBool32
    filterCubicMinmax*: VkBool32

  VkPhysicalDeviceImagelessFramebufferFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    imagelessFramebuffer*: VkBool32

  VkPhysicalDeviceImagelessFramebufferFeaturesKHR* = object

  VkFramebufferAttachmentsCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    attachmentImageInfoCount*: uint32
    pAttachmentImageInfos*: ptr VkFramebufferAttachmentImageInfo

  VkFramebufferAttachmentsCreateInfoKHR* = object

  VkFramebufferAttachmentImageInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkImageCreateFlags
    usage*: VkImageUsageFlags
    width*: uint32
    height*: uint32
    layerCount*: uint32
    viewFormatCount*: uint32
    pViewFormats*: ptr VkFormat

  VkFramebufferAttachmentImageInfoKHR* = object

  VkRenderPassAttachmentBeginInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    attachmentCount*: uint32
    pAttachments*: ptr VkImageView

  VkRenderPassAttachmentBeginInfoKHR* = object

  VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    textureCompressionASTC_HDR*: VkBool32

  VkPhysicalDeviceCooperativeMatrixFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    cooperativeMatrix*: VkBool32
    cooperativeMatrixRobustBufferAccess*: VkBool32

  VkPhysicalDeviceCooperativeMatrixPropertiesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    cooperativeMatrixSupportedStages*: VkShaderStageFlags

  VkCooperativeMatrixPropertiesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    MSize*: uint32
    NSize*: uint32
    KSize*: uint32
    AType*: VkComponentTypeNV
    BType*: VkComponentTypeNV
    CType*: VkComponentTypeNV
    DType*: VkComponentTypeNV
    scope*: VkScopeNV

  VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    ycbcrImageArrays*: VkBool32

  VkImageViewHandleInfoNVX* = object
    sType*: VkStructureType
    pNext*: pointer
    imageView*: VkImageView
    descriptorType*: VkDescriptorType
    sampler*: VkSampler

  VkImageViewAddressPropertiesNVX* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceAddress*: VkDeviceAddress
    size*: VkDeviceSize

  VkPresentFrameTokenGGP* = object
    sType*: VkStructureType
    pNext*: pointer
    frameToken*: GgpFrameToken

  VkPipelineCreationFeedbackEXT* = object
    flags*: VkPipelineCreationFeedbackFlagsEXT
    duration*: uint64

  VkPipelineCreationFeedbackCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    pPipelineCreationFeedback*: ptr VkPipelineCreationFeedbackEXT
    pipelineStageCreationFeedbackCount*: uint32
    pPipelineStageCreationFeedbacks*: ptr ptr VkPipelineCreationFeedbackEXT

  VkSurfaceFullScreenExclusiveInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    fullScreenExclusive*: VkFullScreenExclusiveEXT

  VkSurfaceFullScreenExclusiveWin32InfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    hmonitor*: HMONITOR

  VkSurfaceCapabilitiesFullScreenExclusiveEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    fullScreenExclusiveSupported*: VkBool32

  VkPhysicalDevicePerformanceQueryFeaturesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    performanceCounterQueryPools*: VkBool32
    performanceCounterMultipleQueryPools*: VkBool32

  VkPhysicalDevicePerformanceQueryPropertiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    allowCommandBufferQueryCopies*: VkBool32

  VkPerformanceCounterKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    unit*: VkPerformanceCounterUnitKHR
    scope*: VkPerformanceCounterScopeKHR
    storage*: VkPerformanceCounterStorageKHR
    uuid*: array[VK_UUID_SIZE, uint8]

  VkPerformanceCounterDescriptionKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPerformanceCounterDescriptionFlagsKHR
    name*: array[VK_MAX_DESCRIPTION_SIZE, char]
    category*: array[VK_MAX_DESCRIPTION_SIZE, char]
    description*: array[VK_MAX_DESCRIPTION_SIZE, char]

  VkQueryPoolPerformanceCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    queueFamilyIndex*: uint32
    counterIndexCount*: uint32
    pCounterIndices*: ptr uint32

  VkPerformanceCounterResultKHR* {.union.} = object
    int32*: int32
    int64*: int64
    uint32*: uint32
    uint64*: uint64
    float32*: float32
    float64*: float64

  VkAcquireProfilingLockInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkAcquireProfilingLockFlagsKHR
    timeout*: uint64

  VkPerformanceQuerySubmitInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    counterPassIndex*: uint32

  VkHeadlessSurfaceCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkHeadlessSurfaceCreateFlagsEXT

  VkPhysicalDeviceCoverageReductionModeFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    coverageReductionMode*: VkBool32

  VkPipelineCoverageReductionStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineCoverageReductionStateCreateFlagsNV
    coverageReductionMode*: VkCoverageReductionModeNV

  VkFramebufferMixedSamplesCombinationNV* = object
    sType*: VkStructureType
    pNext*: pointer
    coverageReductionMode*: VkCoverageReductionModeNV
    rasterizationSamples*: VkSampleCountFlagBits
    depthStencilSamples*: VkSampleCountFlags
    colorSamples*: VkSampleCountFlags

  VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderIntegerFunctions2*: VkBool32

  VkPerformanceValueDataINTEL* {.union.} = object
    value32*: uint32
    value64*: uint64
    valueFloat*: float32
    valueBool*: VkBool32
    valueString*: cstring

  VkPerformanceValueINTEL* = object
    `type`*: VkPerformanceValueTypeINTEL
    data*: VkPerformanceValueDataINTEL

  VkInitializePerformanceApiInfoINTEL* = object
    sType*: VkStructureType
    pNext*: pointer
    pUserData*: pointer

  VkQueryPoolPerformanceQueryCreateInfoINTEL* = object
    sType*: VkStructureType
    pNext*: pointer
    performanceCountersSampling*: VkQueryPoolSamplingModeINTEL

  VkQueryPoolCreateInfoINTEL* = object

  VkPerformanceMarkerInfoINTEL* = object
    sType*: VkStructureType
    pNext*: pointer
    marker*: uint64

  VkPerformanceStreamMarkerInfoINTEL* = object
    sType*: VkStructureType
    pNext*: pointer
    marker*: uint32

  VkPerformanceOverrideInfoINTEL* = object
    sType*: VkStructureType
    pNext*: pointer
    `type`*: VkPerformanceOverrideTypeINTEL
    enable*: VkBool32
    parameter*: uint64

  VkPerformanceConfigurationAcquireInfoINTEL* = object
    sType*: VkStructureType
    pNext*: pointer
    `type`*: VkPerformanceConfigurationTypeINTEL

  VkPhysicalDeviceShaderClockFeaturesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderSubgroupClock*: VkBool32
    shaderDeviceClock*: VkBool32

  VkPhysicalDeviceIndexTypeUint8FeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    indexTypeUint8*: VkBool32

  VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderSMCount*: uint32
    shaderWarpsPerSM*: uint32

  VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderSMBuiltins*: VkBool32

  VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    fragmentShaderSampleInterlock*: VkBool32
    fragmentShaderPixelInterlock*: VkBool32
    fragmentShaderShadingRateInterlock*: VkBool32

  VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    separateDepthStencilLayouts*: VkBool32

  VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR* = object

  VkAttachmentReferenceStencilLayout* = object
    sType*: VkStructureType
    pNext*: pointer
    stencilLayout*: VkImageLayout

  VkAttachmentReferenceStencilLayoutKHR* = object

  VkAttachmentDescriptionStencilLayout* = object
    sType*: VkStructureType
    pNext*: pointer
    stencilInitialLayout*: VkImageLayout
    stencilFinalLayout*: VkImageLayout

  VkAttachmentDescriptionStencilLayoutKHR* = object

  VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    pipelineExecutableInfo*: VkBool32

  VkPipelineInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    pipeline*: VkPipeline

  VkPipelineExecutablePropertiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    stages*: VkShaderStageFlags
    name*: array[VK_MAX_DESCRIPTION_SIZE, char]
    description*: array[VK_MAX_DESCRIPTION_SIZE, char]
    subgroupSize*: uint32

  VkPipelineExecutableInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    pipeline*: VkPipeline
    executableIndex*: uint32

  VkPipelineExecutableStatisticValueKHR* {.union.} = object
    b32*: VkBool32
    i64*: int64
    u64*: uint64
    f64*: float64

  VkPipelineExecutableStatisticKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    name*: array[VK_MAX_DESCRIPTION_SIZE, char]
    description*: array[VK_MAX_DESCRIPTION_SIZE, char]
    format*: VkPipelineExecutableStatisticFormatKHR
    value*: VkPipelineExecutableStatisticValueKHR

  VkPipelineExecutableInternalRepresentationKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    name*: array[VK_MAX_DESCRIPTION_SIZE, char]
    description*: array[VK_MAX_DESCRIPTION_SIZE, char]
    isText*: VkBool32
    dataSize*: uint
    pData*: pointer

  VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderDemoteToHelperInvocation*: VkBool32

  VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    texelBufferAlignment*: VkBool32

  VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    storageTexelBufferOffsetAlignmentBytes*: VkDeviceSize
    storageTexelBufferOffsetSingleTexelAlignment*: VkBool32
    uniformTexelBufferOffsetAlignmentBytes*: VkDeviceSize
    uniformTexelBufferOffsetSingleTexelAlignment*: VkBool32

  VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    subgroupSizeControl*: VkBool32
    computeFullSubgroups*: VkBool32

  VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    minSubgroupSize*: uint32
    maxSubgroupSize*: uint32
    maxComputeWorkgroupSubgroups*: uint32
    requiredSubgroupSizeStages*: VkShaderStageFlags

  VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    requiredSubgroupSize*: uint32

  VkMemoryOpaqueCaptureAddressAllocateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    opaqueCaptureAddress*: uint64

  VkMemoryOpaqueCaptureAddressAllocateInfoKHR* = object

  VkDeviceMemoryOpaqueCaptureAddressInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    memory*: VkDeviceMemory

  VkDeviceMemoryOpaqueCaptureAddressInfoKHR* = object

  VkPhysicalDeviceLineRasterizationFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    rectangularLines*: VkBool32
    bresenhamLines*: VkBool32
    smoothLines*: VkBool32
    stippledRectangularLines*: VkBool32
    stippledBresenhamLines*: VkBool32
    stippledSmoothLines*: VkBool32

  VkPhysicalDeviceLineRasterizationPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    lineSubPixelPrecisionBits*: uint32

  VkPipelineRasterizationLineStateCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    lineRasterizationMode*: VkLineRasterizationModeEXT
    stippledLineEnable*: VkBool32
    lineStippleFactor*: uint32
    lineStipplePattern*: uint16

  VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    pipelineCreationCacheControl*: VkBool32

  VkPhysicalDeviceVulkan11Features* = object
    sType*: VkStructureType
    pNext*: pointer
    storageBuffer16BitAccess*: VkBool32
    uniformAndStorageBuffer16BitAccess*: VkBool32
    storagePushConstant16*: VkBool32
    storageInputOutput16*: VkBool32
    multiview*: VkBool32
    multiviewGeometryShader*: VkBool32
    multiviewTessellationShader*: VkBool32
    variablePointersStorageBuffer*: VkBool32
    variablePointers*: VkBool32
    protectedMemory*: VkBool32
    samplerYcbcrConversion*: VkBool32
    shaderDrawParameters*: VkBool32

  VkPhysicalDeviceVulkan11Properties* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceUUID*: array[VK_UUID_SIZE, uint8]
    driverUUID*: array[VK_UUID_SIZE, uint8]
    deviceLUID*: array[VK_LUID_SIZE, uint8]
    deviceNodeMask*: uint32
    deviceLUIDValid*: VkBool32
    subgroupSize*: uint32
    subgroupSupportedStages*: VkShaderStageFlags
    subgroupSupportedOperations*: VkSubgroupFeatureFlags
    subgroupQuadOperationsInAllStages*: VkBool32
    pointClippingBehavior*: VkPointClippingBehavior
    maxMultiviewViewCount*: uint32
    maxMultiviewInstanceIndex*: uint32
    protectedNoFault*: VkBool32
    maxPerSetDescriptors*: uint32
    maxMemoryAllocationSize*: VkDeviceSize

  VkPhysicalDeviceVulkan12Features* = object
    sType*: VkStructureType
    pNext*: pointer
    samplerMirrorClampToEdge*: VkBool32
    drawIndirectCount*: VkBool32
    storageBuffer8BitAccess*: VkBool32
    uniformAndStorageBuffer8BitAccess*: VkBool32
    storagePushConstant8*: VkBool32
    shaderBufferInt64Atomics*: VkBool32
    shaderSharedInt64Atomics*: VkBool32
    shaderFloat16*: VkBool32
    shaderInt8*: VkBool32
    descriptorIndexing*: 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*: VkBool32
    samplerFilterMinmax*: VkBool32
    scalarBlockLayout*: VkBool32
    imagelessFramebuffer*: VkBool32
    uniformBufferStandardLayout*: VkBool32
    shaderSubgroupExtendedTypes*: VkBool32
    separateDepthStencilLayouts*: VkBool32
    hostQueryReset*: VkBool32
    timelineSemaphore*: VkBool32
    bufferDeviceAddress*: VkBool32
    bufferDeviceAddressCaptureReplay*: VkBool32
    bufferDeviceAddressMultiDevice*: VkBool32
    vulkanMemoryModel*: VkBool32
    vulkanMemoryModelDeviceScope*: VkBool32
    vulkanMemoryModelAvailabilityVisibilityChains*: VkBool32
    shaderOutputViewportIndex*: VkBool32
    shaderOutputLayer*: VkBool32
    subgroupBroadcastDynamicId*: VkBool32

  VkPhysicalDeviceVulkan12Properties* = object
    sType*: VkStructureType
    pNext*: pointer
    driverID*: VkDriverId
    driverName*: array[VK_MAX_DRIVER_NAME_SIZE, char]
    driverInfo*: array[VK_MAX_DRIVER_INFO_SIZE, char]
    conformanceVersion*: VkConformanceVersion
    denormBehaviorIndependence*: VkShaderFloatControlsIndependence
    roundingModeIndependence*: VkShaderFloatControlsIndependence
    shaderSignedZeroInfNanPreserveFloat16*: VkBool32
    shaderSignedZeroInfNanPreserveFloat32*: VkBool32
    shaderSignedZeroInfNanPreserveFloat64*: VkBool32
    shaderDenormPreserveFloat16*: VkBool32
    shaderDenormPreserveFloat32*: VkBool32
    shaderDenormPreserveFloat64*: VkBool32
    shaderDenormFlushToZeroFloat16*: VkBool32
    shaderDenormFlushToZeroFloat32*: VkBool32
    shaderDenormFlushToZeroFloat64*: VkBool32
    shaderRoundingModeRTEFloat16*: VkBool32
    shaderRoundingModeRTEFloat32*: VkBool32
    shaderRoundingModeRTEFloat64*: VkBool32
    shaderRoundingModeRTZFloat16*: VkBool32
    shaderRoundingModeRTZFloat32*: VkBool32
    shaderRoundingModeRTZFloat64*: VkBool32
    maxUpdateAfterBindDescriptorsInAllPools*: uint32
    shaderUniformBufferArrayNonUniformIndexingNative*: VkBool32
    shaderSampledImageArrayNonUniformIndexingNative*: VkBool32
    shaderStorageBufferArrayNonUniformIndexingNative*: VkBool32
    shaderStorageImageArrayNonUniformIndexingNative*: VkBool32
    shaderInputAttachmentArrayNonUniformIndexingNative*: VkBool32
    robustBufferAccessUpdateAfterBind*: VkBool32
    quadDivergentImplicitLod*: VkBool32
    maxPerStageDescriptorUpdateAfterBindSamplers*: uint32
    maxPerStageDescriptorUpdateAfterBindUniformBuffers*: uint32
    maxPerStageDescriptorUpdateAfterBindStorageBuffers*: uint32
    maxPerStageDescriptorUpdateAfterBindSampledImages*: uint32
    maxPerStageDescriptorUpdateAfterBindStorageImages*: uint32
    maxPerStageDescriptorUpdateAfterBindInputAttachments*: uint32
    maxPerStageUpdateAfterBindResources*: uint32
    maxDescriptorSetUpdateAfterBindSamplers*: uint32
    maxDescriptorSetUpdateAfterBindUniformBuffers*: uint32
    maxDescriptorSetUpdateAfterBindUniformBuffersDynamic*: uint32
    maxDescriptorSetUpdateAfterBindStorageBuffers*: uint32
    maxDescriptorSetUpdateAfterBindStorageBuffersDynamic*: uint32
    maxDescriptorSetUpdateAfterBindSampledImages*: uint32
    maxDescriptorSetUpdateAfterBindStorageImages*: uint32
    maxDescriptorSetUpdateAfterBindInputAttachments*: uint32
    supportedDepthResolveModes*: VkResolveModeFlags
    supportedStencilResolveModes*: VkResolveModeFlags
    independentResolveNone*: VkBool32
    independentResolve*: VkBool32
    filterMinmaxSingleComponentFormats*: VkBool32
    filterMinmaxImageComponentMapping*: VkBool32
    maxTimelineSemaphoreValueDifference*: uint64
    framebufferIntegerColorSampleCounts*: VkSampleCountFlags

  VkPipelineCompilerControlCreateInfoAMD* = object
    sType*: VkStructureType
    pNext*: pointer
    compilerControlFlags*: VkPipelineCompilerControlFlagsAMD

  VkPhysicalDeviceCoherentMemoryFeaturesAMD* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceCoherentMemory*: VkBool32

  VkPhysicalDeviceToolPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    name*: array[VK_MAX_EXTENSION_NAME_SIZE, char]
    version*: array[VK_MAX_EXTENSION_NAME_SIZE, char]
    purposes*: VkToolPurposeFlagsEXT
    description*: array[VK_MAX_DESCRIPTION_SIZE, char]
    layer*: array[VK_MAX_EXTENSION_NAME_SIZE, char]

  VkSamplerCustomBorderColorCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    customBorderColor*: VkClearColorValue
    format*: VkFormat

  VkPhysicalDeviceCustomBorderColorPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    maxCustomBorderColorSamplers*: uint32

  VkPhysicalDeviceCustomBorderColorFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    customBorderColors*: VkBool32
    customBorderColorWithoutFormat*: VkBool32

  VkDeviceOrHostAddressKHR* {.union.} = object
    deviceAddress*: VkDeviceAddress
    hostAddress*: pointer

  VkDeviceOrHostAddressConstKHR* {.union.} = object
    deviceAddress*: VkDeviceAddress
    hostAddress*: pointer

  VkAccelerationStructureGeometryTrianglesDataKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    vertexFormat*: VkFormat
    vertexData*: VkDeviceOrHostAddressConstKHR
    vertexStride*: VkDeviceSize
    indexType*: VkIndexType
    indexData*: VkDeviceOrHostAddressConstKHR
    transformData*: VkDeviceOrHostAddressConstKHR

  VkAccelerationStructureGeometryAabbsDataKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    data*: VkDeviceOrHostAddressConstKHR
    stride*: VkDeviceSize

  VkAccelerationStructureGeometryInstancesDataKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    arrayOfPointers*: VkBool32
    data*: VkDeviceOrHostAddressConstKHR

  VkAccelerationStructureGeometryDataKHR* {.union.} = object
    triangles*: VkAccelerationStructureGeometryTrianglesDataKHR
    aabbs*: VkAccelerationStructureGeometryAabbsDataKHR
    instances*: VkAccelerationStructureGeometryInstancesDataKHR

  VkAccelerationStructureGeometryKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    geometryType*: VkGeometryTypeKHR
    geometry*: VkAccelerationStructureGeometryDataKHR
    flags*: VkGeometryFlagsKHR

  VkAccelerationStructureBuildGeometryInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    `type`*: VkAccelerationStructureTypeKHR
    flags*: VkBuildAccelerationStructureFlagsKHR
    update*: VkBool32
    srcAccelerationStructure*: VkAccelerationStructureKHR
    dstAccelerationStructure*: VkAccelerationStructureKHR
    geometryArrayOfPointers*: VkBool32
    geometryCount*: uint32
    ppGeometries*: ptr ptr VkAccelerationStructureGeometryKHR
    scratchData*: VkDeviceOrHostAddressKHR

  VkAccelerationStructureBuildOffsetInfoKHR* = object
    primitiveCount*: uint32
    primitiveOffset*: uint32
    firstVertex*: uint32
    transformOffset*: uint32

  VkAccelerationStructureCreateGeometryTypeInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    geometryType*: VkGeometryTypeKHR
    maxPrimitiveCount*: uint32
    indexType*: VkIndexType
    maxVertexCount*: uint32
    vertexFormat*: VkFormat
    allowsTransforms*: VkBool32

  VkAccelerationStructureCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    compactedSize*: VkDeviceSize
    `type`*: VkAccelerationStructureTypeKHR
    flags*: VkBuildAccelerationStructureFlagsKHR
    maxGeometryCount*: uint32
    pGeometryInfos*: ptr VkAccelerationStructureCreateGeometryTypeInfoKHR
    deviceAddress*: VkDeviceAddress

  VkAabbPositionsKHR* = object
    minX*: float32
    minY*: float32
    minZ*: float32
    maxX*: float32
    maxY*: float32
    maxZ*: float32

  VkAabbPositionsNV* = object

  VkTransformMatrixKHR* = object
    matrix*: array[3, float32]

  VkTransformMatrixNV* = object

  VkAccelerationStructureInstanceKHR* = object
    transform*: VkTransformMatrixKHR
    instanceCustomIndex*: uint32
    mask*: uint32
    instanceShaderBindingTableRecordOffset*: uint32
    flags*: VkGeometryInstanceFlagsKHR
    accelerationStructureReference*: uint64

  VkAccelerationStructureInstanceNV* = object

  VkAccelerationStructureDeviceAddressInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    accelerationStructure*: VkAccelerationStructureKHR

  VkAccelerationStructureVersionKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    versionData*: ptr uint8

  VkCopyAccelerationStructureInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    src*: VkAccelerationStructureKHR
    dst*: VkAccelerationStructureKHR
    mode*: VkCopyAccelerationStructureModeKHR

  VkCopyAccelerationStructureToMemoryInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    src*: VkAccelerationStructureKHR
    dst*: VkDeviceOrHostAddressKHR
    mode*: VkCopyAccelerationStructureModeKHR

  VkCopyMemoryToAccelerationStructureInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    src*: VkDeviceOrHostAddressConstKHR
    dst*: VkAccelerationStructureKHR
    mode*: VkCopyAccelerationStructureModeKHR

  VkRayTracingPipelineInterfaceCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    maxPayloadSize*: uint32
    maxAttributeSize*: uint32
    maxCallableSize*: uint32

  VkDeferredOperationInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    operationHandle*: VkDeferredOperationKHR

  VkPipelineLibraryCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    libraryCount*: uint32
    pLibraries*: ptr VkPipeline

  VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    extendedDynamicState*: VkBool32

  VkRenderPassTransformBeginInfoQCOM* = object
    sType*: VkStructureType
    pNext*: pointer
    transform*: VkSurfaceTransformFlagBitsKHR

  VkCommandBufferInheritanceRenderPassTransformInfoQCOM* = object
    sType*: VkStructureType
    pNext*: pointer
    transform*: VkSurfaceTransformFlagBitsKHR
    renderArea*: VkRect2D

  VkPhysicalDeviceDiagnosticsConfigFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    diagnosticsConfig*: VkBool32

  VkDeviceDiagnosticsConfigCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDeviceDiagnosticsConfigFlagsNV

  VkPhysicalDeviceRobustness2FeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    robustBufferAccess2*: VkBool32
    robustImageAccess2*: VkBool32
    nullDescriptor*: VkBool32

  VkPhysicalDeviceRobustness2PropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    robustStorageBufferAccessSizeAlignment*: VkDeviceSize
    robustUniformBufferAccessSizeAlignment*: VkDeviceSize

  VkPhysicalDeviceImageRobustnessFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    robustImageAccess*: VkBool32

  VkPhysicalDevice4444FormatsFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    formatA4R4G4B4*: VkBool32
    formatA4B4G4R4*: VkBool32

# Constructors

proc newVkOffset2D*(x: int32, y: int32): VkOffset2D =
  result.x = x
  result.y = y

proc newVkOffset3D*(x: int32, y: int32, z: int32): VkOffset3D =
  result.x = x
  result.y = y
  result.z = z

proc newVkExtent2D*(width: uint32, height: uint32): VkExtent2D =
  result.width = width
  result.height = height

proc newVkExtent3D*(width: uint32, height: uint32, depth: uint32): VkExtent3D =
  result.width = width
  result.height = height
  result.depth = depth

proc newVkViewport*(x: float32, y: float32, width: float32, height: float32, minDepth: float32, maxDepth: float32): VkViewport =
  result.x = x
  result.y = y
  result.width = width
  result.height = height
  result.minDepth = minDepth
  result.maxDepth = maxDepth

proc newVkRect2D*(offset: VkOffset2D, extent: VkExtent2D): VkRect2D =
  result.offset = offset
  result.extent = extent

proc newVkClearRect*(rect: VkRect2D, baseArrayLayer: uint32, layerCount: uint32): VkClearRect =
  result.rect = rect
  result.baseArrayLayer = baseArrayLayer
  result.layerCount = layerCount

proc newVkComponentMapping*(r: VkComponentSwizzle, g: VkComponentSwizzle, b: VkComponentSwizzle, a: VkComponentSwizzle): VkComponentMapping =
  result.r = r
  result.g = g
  result.b = b
  result.a = a

proc newVkPhysicalDeviceProperties*(apiVersion: uint32, driverVersion: uint32, vendorID: uint32, deviceID: uint32, deviceType: VkPhysicalDeviceType, deviceName: array[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, char], pipelineCacheUUID: array[VK_UUID_SIZE, uint8], limits: VkPhysicalDeviceLimits, sparseProperties: VkPhysicalDeviceSparseProperties): VkPhysicalDeviceProperties =
  result.apiVersion = apiVersion
  result.driverVersion = driverVersion
  result.vendorID = vendorID
  result.deviceID = deviceID
  result.deviceType = deviceType
  result.deviceName = deviceName
  result.pipelineCacheUUID = pipelineCacheUUID
  result.limits = limits
  result.sparseProperties = sparseProperties

proc newVkExtensionProperties*(extensionName: array[VK_MAX_EXTENSION_NAME_SIZE, char], specVersion: uint32): VkExtensionProperties =
  result.extensionName = extensionName
  result.specVersion = specVersion

proc newVkLayerProperties*(layerName: array[VK_MAX_EXTENSION_NAME_SIZE, char], specVersion: uint32, implementationVersion: uint32, description: array[VK_MAX_DESCRIPTION_SIZE, char]): VkLayerProperties =
  result.layerName = layerName
  result.specVersion = specVersion
  result.implementationVersion = implementationVersion
  result.description = description

proc newVkApplicationInfo*(sType: VkStructureType = VkStructureTypeApplicationInfo, pNext: pointer = nil, pApplicationName: cstring, applicationVersion: uint32, pEngineName: cstring, engineVersion: uint32, apiVersion: uint32): VkApplicationInfo =
  result.sType = sType
  result.pNext = pNext
  result.pApplicationName = pApplicationName
  result.applicationVersion = applicationVersion
  result.pEngineName = pEngineName
  result.engineVersion = engineVersion
  result.apiVersion = apiVersion

proc newVkAllocationCallbacks*(pUserData: pointer = nil, pfnAllocation: PFN_vkAllocationFunction, pfnReallocation: PFN_vkReallocationFunction, pfnFree: PFN_vkFreeFunction, pfnInternalAllocation: PFN_vkInternalAllocationNotification, pfnInternalFree: PFN_vkInternalFreeNotification): VkAllocationCallbacks =
  result.pUserData = pUserData
  result.pfnAllocation = pfnAllocation
  result.pfnReallocation = pfnReallocation
  result.pfnFree = pfnFree
  result.pfnInternalAllocation = pfnInternalAllocation
  result.pfnInternalFree = pfnInternalFree

proc newVkDeviceQueueCreateInfo*(sType: VkStructureType = VkStructureTypeDeviceQueueCreateInfo, pNext: pointer = nil, flags: VkDeviceQueueCreateFlags = 0.VkDeviceQueueCreateFlags, queueFamilyIndex: uint32, queueCount: uint32, pQueuePriorities: ptr float32): VkDeviceQueueCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.queueFamilyIndex = queueFamilyIndex
  result.queueCount = queueCount
  result.pQueuePriorities = pQueuePriorities

proc newVkDeviceCreateInfo*(sType: VkStructureType = VkStructureTypeDeviceCreateInfo, pNext: pointer = nil, flags: VkDeviceCreateFlags = 0.VkDeviceCreateFlags, queueCreateInfoCount: uint32, pQueueCreateInfos: ptr VkDeviceQueueCreateInfo, enabledLayerCount: uint32, ppEnabledLayerNames: cstringArray, enabledExtensionCount: uint32, ppEnabledExtensionNames: cstringArray, pEnabledFeatures: ptr VkPhysicalDeviceFeatures): VkDeviceCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.queueCreateInfoCount = queueCreateInfoCount
  result.pQueueCreateInfos = pQueueCreateInfos
  result.enabledLayerCount = enabledLayerCount
  result.ppEnabledLayerNames = ppEnabledLayerNames
  result.enabledExtensionCount = enabledExtensionCount
  result.ppEnabledExtensionNames = ppEnabledExtensionNames
  result.pEnabledFeatures = pEnabledFeatures

proc newVkInstanceCreateInfo*(sType: VkStructureType = VkStructureTypeInstanceCreateInfo, pNext: pointer = nil, flags: VkInstanceCreateFlags = 0.VkInstanceCreateFlags, pApplicationInfo: ptr VkApplicationInfo, enabledLayerCount: uint32, ppEnabledLayerNames: cstringArray, enabledExtensionCount: uint32, ppEnabledExtensionNames: cstringArray): VkInstanceCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.pApplicationInfo = pApplicationInfo
  result.enabledLayerCount = enabledLayerCount
  result.ppEnabledLayerNames = ppEnabledLayerNames
  result.enabledExtensionCount = enabledExtensionCount
  result.ppEnabledExtensionNames = ppEnabledExtensionNames

proc newVkQueueFamilyProperties*(queueFlags: VkQueueFlags, queueCount: uint32, timestampValidBits: uint32, minImageTransferGranularity: VkExtent3D): VkQueueFamilyProperties =
  result.queueFlags = queueFlags
  result.queueCount = queueCount
  result.timestampValidBits = timestampValidBits
  result.minImageTransferGranularity = minImageTransferGranularity

proc newVkPhysicalDeviceMemoryProperties*(memoryTypeCount: uint32, memoryTypes: array[VK_MAX_MEMORY_TYPES, VkMemoryType], memoryHeapCount: uint32, memoryHeaps: array[VK_MAX_MEMORY_HEAPS, VkMemoryHeap]): VkPhysicalDeviceMemoryProperties =
  result.memoryTypeCount = memoryTypeCount
  result.memoryTypes = memoryTypes
  result.memoryHeapCount = memoryHeapCount
  result.memoryHeaps = memoryHeaps

proc newVkMemoryAllocateInfo*(sType: VkStructureType = VkStructureTypeMemoryAllocateInfo, pNext: pointer = nil, allocationSize: VkDeviceSize, memoryTypeIndex: uint32): VkMemoryAllocateInfo =
  result.sType = sType
  result.pNext = pNext
  result.allocationSize = allocationSize
  result.memoryTypeIndex = memoryTypeIndex

proc newVkMemoryRequirements*(size: VkDeviceSize, alignment: VkDeviceSize, memoryTypeBits: uint32): VkMemoryRequirements =
  result.size = size
  result.alignment = alignment
  result.memoryTypeBits = memoryTypeBits

proc newVkSparseImageFormatProperties*(aspectMask: VkImageAspectFlags, imageGranularity: VkExtent3D, flags: VkSparseImageFormatFlags = 0.VkSparseImageFormatFlags): VkSparseImageFormatProperties =
  result.aspectMask = aspectMask
  result.imageGranularity = imageGranularity
  result.flags = flags

proc newVkSparseImageMemoryRequirements*(formatProperties: VkSparseImageFormatProperties, imageMipTailFirstLod: uint32, imageMipTailSize: VkDeviceSize, imageMipTailOffset: VkDeviceSize, imageMipTailStride: VkDeviceSize): VkSparseImageMemoryRequirements =
  result.formatProperties = formatProperties
  result.imageMipTailFirstLod = imageMipTailFirstLod
  result.imageMipTailSize = imageMipTailSize
  result.imageMipTailOffset = imageMipTailOffset
  result.imageMipTailStride = imageMipTailStride

proc newVkMemoryType*(propertyFlags: VkMemoryPropertyFlags, heapIndex: uint32): VkMemoryType =
  result.propertyFlags = propertyFlags
  result.heapIndex = heapIndex

proc newVkMemoryHeap*(size: VkDeviceSize, flags: VkMemoryHeapFlags = 0.VkMemoryHeapFlags): VkMemoryHeap =
  result.size = size
  result.flags = flags

proc newVkMappedMemoryRange*(sType: VkStructureType = VkStructureTypeMappedMemoryRange, pNext: pointer = nil, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize): VkMappedMemoryRange =
  result.sType = sType
  result.pNext = pNext
  result.memory = memory
  result.offset = offset
  result.size = size

proc newVkFormatProperties*(linearTilingFeatures: VkFormatFeatureFlags, optimalTilingFeatures: VkFormatFeatureFlags, bufferFeatures: VkFormatFeatureFlags): VkFormatProperties =
  result.linearTilingFeatures = linearTilingFeatures
  result.optimalTilingFeatures = optimalTilingFeatures
  result.bufferFeatures = bufferFeatures

proc newVkImageFormatProperties*(maxExtent: VkExtent3D, maxMipLevels: uint32, maxArrayLayers: uint32, sampleCounts: VkSampleCountFlags, maxResourceSize: VkDeviceSize): VkImageFormatProperties =
  result.maxExtent = maxExtent
  result.maxMipLevels = maxMipLevels
  result.maxArrayLayers = maxArrayLayers
  result.sampleCounts = sampleCounts
  result.maxResourceSize = maxResourceSize

proc newVkDescriptorBufferInfo*(buffer: VkBuffer, offset: VkDeviceSize, range: VkDeviceSize): VkDescriptorBufferInfo =
  result.buffer = buffer
  result.offset = offset
  result.range = range

proc newVkDescriptorImageInfo*(sampler: VkSampler, imageView: VkImageView, imageLayout: VkImageLayout): VkDescriptorImageInfo =
  result.sampler = sampler
  result.imageView = imageView
  result.imageLayout = imageLayout

proc newVkWriteDescriptorSet*(sType: VkStructureType = VkStructureTypeWriteDescriptorSet, pNext: pointer = nil, dstSet: VkDescriptorSet, dstBinding: uint32, dstArrayElement: uint32, descriptorCount: uint32, descriptorType: VkDescriptorType, pImageInfo: ptr VkDescriptorImageInfo, pBufferInfo: ptr ptr VkDescriptorBufferInfo, pTexelBufferView: ptr VkBufferView): VkWriteDescriptorSet =
  result.sType = sType
  result.pNext = pNext
  result.dstSet = dstSet
  result.dstBinding = dstBinding
  result.dstArrayElement = dstArrayElement
  result.descriptorCount = descriptorCount
  result.descriptorType = descriptorType
  result.pImageInfo = pImageInfo
  result.pBufferInfo = pBufferInfo
  result.pTexelBufferView = pTexelBufferView

proc newVkCopyDescriptorSet*(sType: VkStructureType = VkStructureTypeCopyDescriptorSet, pNext: pointer = nil, srcSet: VkDescriptorSet, srcBinding: uint32, srcArrayElement: uint32, dstSet: VkDescriptorSet, dstBinding: uint32, dstArrayElement: uint32, descriptorCount: uint32): VkCopyDescriptorSet =
  result.sType = sType
  result.pNext = pNext
  result.srcSet = srcSet
  result.srcBinding = srcBinding
  result.srcArrayElement = srcArrayElement
  result.dstSet = dstSet
  result.dstBinding = dstBinding
  result.dstArrayElement = dstArrayElement
  result.descriptorCount = descriptorCount

proc newVkBufferCreateInfo*(sType: VkStructureType = VkStructureTypeBufferCreateInfo, pNext: pointer = nil, flags: VkBufferCreateFlags = 0.VkBufferCreateFlags, size: VkDeviceSize, usage: VkBufferUsageFlags, sharingMode: VkSharingMode, queueFamilyIndexCount: uint32, pQueueFamilyIndices: ptr uint32): VkBufferCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.size = size
  result.usage = usage
  result.sharingMode = sharingMode
  result.queueFamilyIndexCount = queueFamilyIndexCount
  result.pQueueFamilyIndices = pQueueFamilyIndices

proc newVkBufferViewCreateInfo*(sType: VkStructureType = VkStructureTypeBufferViewCreateInfo, pNext: pointer = nil, flags: VkBufferViewCreateFlags = 0.VkBufferViewCreateFlags, buffer: VkBuffer, format: VkFormat, offset: VkDeviceSize, range: VkDeviceSize): VkBufferViewCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.buffer = buffer
  result.format = format
  result.offset = offset
  result.range = range

proc newVkImageSubresource*(aspectMask: VkImageAspectFlags, mipLevel: uint32, arrayLayer: uint32): VkImageSubresource =
  result.aspectMask = aspectMask
  result.mipLevel = mipLevel
  result.arrayLayer = arrayLayer

proc newVkImageSubresourceLayers*(aspectMask: VkImageAspectFlags, mipLevel: uint32, baseArrayLayer: uint32, layerCount: uint32): VkImageSubresourceLayers =
  result.aspectMask = aspectMask
  result.mipLevel = mipLevel
  result.baseArrayLayer = baseArrayLayer
  result.layerCount = layerCount

proc newVkImageSubresourceRange*(aspectMask: VkImageAspectFlags, baseMipLevel: uint32, levelCount: uint32, baseArrayLayer: uint32, layerCount: uint32): VkImageSubresourceRange =
  result.aspectMask = aspectMask
  result.baseMipLevel = baseMipLevel
  result.levelCount = levelCount
  result.baseArrayLayer = baseArrayLayer
  result.layerCount = layerCount

proc newVkMemoryBarrier*(sType: VkStructureType = VkStructureTypeMemoryBarrier, pNext: pointer = nil, srcAccessMask: VkAccessFlags, dstAccessMask: VkAccessFlags): VkMemoryBarrier =
  result.sType = sType
  result.pNext = pNext
  result.srcAccessMask = srcAccessMask
  result.dstAccessMask = dstAccessMask

proc newVkBufferMemoryBarrier*(sType: VkStructureType = VkStructureTypeBufferMemoryBarrier, pNext: pointer = nil, srcAccessMask: VkAccessFlags, dstAccessMask: VkAccessFlags, srcQueueFamilyIndex: uint32, dstQueueFamilyIndex: uint32, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize): VkBufferMemoryBarrier =
  result.sType = sType
  result.pNext = pNext
  result.srcAccessMask = srcAccessMask
  result.dstAccessMask = dstAccessMask
  result.srcQueueFamilyIndex = srcQueueFamilyIndex
  result.dstQueueFamilyIndex = dstQueueFamilyIndex
  result.buffer = buffer
  result.offset = offset
  result.size = size

proc newVkImageMemoryBarrier*(sType: VkStructureType = VkStructureTypeImageMemoryBarrier, pNext: pointer = nil, srcAccessMask: VkAccessFlags, dstAccessMask: VkAccessFlags, oldLayout: VkImageLayout, newLayout: VkImageLayout, srcQueueFamilyIndex: uint32, dstQueueFamilyIndex: uint32, image: VkImage, subresourceRange: VkImageSubresourceRange): VkImageMemoryBarrier =
  result.sType = sType
  result.pNext = pNext
  result.srcAccessMask = srcAccessMask
  result.dstAccessMask = dstAccessMask
  result.oldLayout = oldLayout
  result.newLayout = newLayout
  result.srcQueueFamilyIndex = srcQueueFamilyIndex
  result.dstQueueFamilyIndex = dstQueueFamilyIndex
  result.image = image
  result.subresourceRange = subresourceRange

proc newVkImageCreateInfo*(sType: VkStructureType = VkStructureTypeImageCreateInfo, pNext: pointer = nil, flags: VkImageCreateFlags = 0.VkImageCreateFlags, imageType: VkImageType, format: VkFormat, extent: VkExtent3D, mipLevels: uint32, arrayLayers: uint32, samples: VkSampleCountFlagBits, tiling: VkImageTiling, usage: VkImageUsageFlags, sharingMode: VkSharingMode, queueFamilyIndexCount: uint32, pQueueFamilyIndices: ptr uint32, initialLayout: VkImageLayout): VkImageCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.imageType = imageType
  result.format = format
  result.extent = extent
  result.mipLevels = mipLevels
  result.arrayLayers = arrayLayers
  result.samples = samples
  result.tiling = tiling
  result.usage = usage
  result.sharingMode = sharingMode
  result.queueFamilyIndexCount = queueFamilyIndexCount
  result.pQueueFamilyIndices = pQueueFamilyIndices
  result.initialLayout = initialLayout

proc newVkSubresourceLayout*(offset: VkDeviceSize, size: VkDeviceSize, rowPitch: VkDeviceSize, arrayPitch: VkDeviceSize, depthPitch: VkDeviceSize): VkSubresourceLayout =
  result.offset = offset
  result.size = size
  result.rowPitch = rowPitch
  result.arrayPitch = arrayPitch
  result.depthPitch = depthPitch

proc newVkImageViewCreateInfo*(sType: VkStructureType = VkStructureTypeImageViewCreateInfo, pNext: pointer = nil, flags: VkImageViewCreateFlags = 0.VkImageViewCreateFlags, image: VkImage, viewType: VkImageViewType, format: VkFormat, components: VkComponentMapping, subresourceRange: VkImageSubresourceRange): VkImageViewCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.image = image
  result.viewType = viewType
  result.format = format
  result.components = components
  result.subresourceRange = subresourceRange

proc newVkBufferCopy*(srcOffset: VkDeviceSize, dstOffset: VkDeviceSize, size: VkDeviceSize): VkBufferCopy =
  result.srcOffset = srcOffset
  result.dstOffset = dstOffset
  result.size = size

proc newVkSparseMemoryBind*(resourceOffset: VkDeviceSize, size: VkDeviceSize, memory: VkDeviceMemory, memoryOffset: VkDeviceSize, flags: VkSparseMemoryBindFlags = 0.VkSparseMemoryBindFlags): VkSparseMemoryBind =
  result.resourceOffset = resourceOffset
  result.size = size
  result.memory = memory
  result.memoryOffset = memoryOffset
  result.flags = flags

proc newVkSparseImageMemoryBind*(subresource: VkImageSubresource, offset: VkOffset3D, extent: VkExtent3D, memory: VkDeviceMemory, memoryOffset: VkDeviceSize, flags: VkSparseMemoryBindFlags = 0.VkSparseMemoryBindFlags): VkSparseImageMemoryBind =
  result.subresource = subresource
  result.offset = offset
  result.extent = extent
  result.memory = memory
  result.memoryOffset = memoryOffset
  result.flags = flags

proc newVkSparseBufferMemoryBindInfo*(buffer: VkBuffer, bindCount: uint32, pBinds: ptr VkSparseMemoryBind): VkSparseBufferMemoryBindInfo =
  result.buffer = buffer
  result.bindCount = bindCount
  result.pBinds = pBinds

proc newVkSparseImageOpaqueMemoryBindInfo*(image: VkImage, bindCount: uint32, pBinds: ptr VkSparseMemoryBind): VkSparseImageOpaqueMemoryBindInfo =
  result.image = image
  result.bindCount = bindCount
  result.pBinds = pBinds

proc newVkSparseImageMemoryBindInfo*(image: VkImage, bindCount: uint32, pBinds: ptr VkSparseImageMemoryBind): VkSparseImageMemoryBindInfo =
  result.image = image
  result.bindCount = bindCount
  result.pBinds = pBinds

proc newVkBindSparseInfo*(sType: VkStructureType = VkStructureTypeBindSparseInfo, pNext: pointer = nil, waitSemaphoreCount: uint32, pWaitSemaphores: ptr VkSemaphore, bufferBindCount: uint32, pBufferBinds: ptr VkSparseBufferMemoryBindInfo, imageOpaqueBindCount: uint32, pImageOpaqueBinds: ptr VkSparseImageOpaqueMemoryBindInfo, imageBindCount: uint32, pImageBinds: ptr VkSparseImageMemoryBindInfo, signalSemaphoreCount: uint32, pSignalSemaphores: ptr VkSemaphore): VkBindSparseInfo =
  result.sType = sType
  result.pNext = pNext
  result.waitSemaphoreCount = waitSemaphoreCount
  result.pWaitSemaphores = pWaitSemaphores
  result.bufferBindCount = bufferBindCount
  result.pBufferBinds = pBufferBinds
  result.imageOpaqueBindCount = imageOpaqueBindCount
  result.pImageOpaqueBinds = pImageOpaqueBinds
  result.imageBindCount = imageBindCount
  result.pImageBinds = pImageBinds
  result.signalSemaphoreCount = signalSemaphoreCount
  result.pSignalSemaphores = pSignalSemaphores

proc newVkImageCopy*(srcSubresource: VkImageSubresourceLayers, srcOffset: VkOffset3D, dstSubresource: VkImageSubresourceLayers, dstOffset: VkOffset3D, extent: VkExtent3D): VkImageCopy =
  result.srcSubresource = srcSubresource
  result.srcOffset = srcOffset
  result.dstSubresource = dstSubresource
  result.dstOffset = dstOffset
  result.extent = extent

proc newVkImageBlit*(srcSubresource: VkImageSubresourceLayers, srcOffsets: array[2, VkOffset3D], dstSubresource: VkImageSubresourceLayers, dstOffsets: array[2, VkOffset3D]): VkImageBlit =
  result.srcSubresource = srcSubresource
  result.srcOffsets = srcOffsets
  result.dstSubresource = dstSubresource
  result.dstOffsets = dstOffsets

proc newVkBufferImageCopy*(bufferOffset: VkDeviceSize, bufferRowLength: uint32, bufferImageHeight: uint32, imageSubresource: VkImageSubresourceLayers, imageOffset: VkOffset3D, imageExtent: VkExtent3D): VkBufferImageCopy =
  result.bufferOffset = bufferOffset
  result.bufferRowLength = bufferRowLength
  result.bufferImageHeight = bufferImageHeight
  result.imageSubresource = imageSubresource
  result.imageOffset = imageOffset
  result.imageExtent = imageExtent

proc newVkImageResolve*(srcSubresource: VkImageSubresourceLayers, srcOffset: VkOffset3D, dstSubresource: VkImageSubresourceLayers, dstOffset: VkOffset3D, extent: VkExtent3D): VkImageResolve =
  result.srcSubresource = srcSubresource
  result.srcOffset = srcOffset
  result.dstSubresource = dstSubresource
  result.dstOffset = dstOffset
  result.extent = extent

proc newVkShaderModuleCreateInfo*(sType: VkStructureType = VkStructureTypeShaderModuleCreateInfo, pNext: pointer = nil, flags: VkShaderModuleCreateFlags = 0.VkShaderModuleCreateFlags, codeSize: uint, pCode: ptr uint32): VkShaderModuleCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.codeSize = codeSize
  result.pCode = pCode

proc newVkDescriptorSetLayoutBinding*(binding: uint32, descriptorType: VkDescriptorType, descriptorCount: uint32, stageFlags: VkShaderStageFlags, pImmutableSamplers: ptr VkSampler): VkDescriptorSetLayoutBinding =
  result.binding = binding
  result.descriptorType = descriptorType
  result.descriptorCount = descriptorCount
  result.stageFlags = stageFlags
  result.pImmutableSamplers = pImmutableSamplers

proc newVkDescriptorSetLayoutCreateInfo*(sType: VkStructureType = VkStructureTypeDescriptorSetLayoutCreateInfo, pNext: pointer = nil, flags: VkDescriptorSetLayoutCreateFlags = 0.VkDescriptorSetLayoutCreateFlags, bindingCount: uint32, pBindings: ptr VkDescriptorSetLayoutBinding): VkDescriptorSetLayoutCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.bindingCount = bindingCount
  result.pBindings = pBindings

proc newVkDescriptorPoolSize*(`type`: VkDescriptorType, descriptorCount: uint32): VkDescriptorPoolSize =
  result.`type` = `type`
  result.descriptorCount = descriptorCount

proc newVkDescriptorPoolCreateInfo*(sType: VkStructureType = VkStructureTypeDescriptorPoolCreateInfo, pNext: pointer = nil, flags: VkDescriptorPoolCreateFlags = 0.VkDescriptorPoolCreateFlags, maxSets: uint32, poolSizeCount: uint32, pPoolSizes: ptr VkDescriptorPoolSize): VkDescriptorPoolCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.maxSets = maxSets
  result.poolSizeCount = poolSizeCount
  result.pPoolSizes = pPoolSizes

proc newVkDescriptorSetAllocateInfo*(sType: VkStructureType = VkStructureTypeDescriptorSetAllocateInfo, pNext: pointer = nil, descriptorPool: VkDescriptorPool, descriptorSetCount: uint32, pSetLayouts: ptr VkDescriptorSetLayout): VkDescriptorSetAllocateInfo =
  result.sType = sType
  result.pNext = pNext
  result.descriptorPool = descriptorPool
  result.descriptorSetCount = descriptorSetCount
  result.pSetLayouts = pSetLayouts

proc newVkSpecializationMapEntry*(constantID: uint32, offset: uint32, size: uint): VkSpecializationMapEntry =
  result.constantID = constantID
  result.offset = offset
  result.size = size

proc newVkSpecializationInfo*(mapEntryCount: uint32, pMapEntries: ptr VkSpecializationMapEntry, dataSize: uint, pData: pointer = nil): VkSpecializationInfo =
  result.mapEntryCount = mapEntryCount
  result.pMapEntries = pMapEntries
  result.dataSize = dataSize
  result.pData = pData

proc newVkPipelineShaderStageCreateInfo*(sType: VkStructureType = VkStructureTypePipelineShaderStageCreateInfo, pNext: pointer = nil, flags: VkPipelineShaderStageCreateFlags = 0.VkPipelineShaderStageCreateFlags, stage: VkShaderStageFlagBits, module: VkShaderModule, pName: cstring, pSpecializationInfo: ptr VkSpecializationInfo): VkPipelineShaderStageCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.stage = stage
  result.module = module
  result.pName = pName
  result.pSpecializationInfo = pSpecializationInfo

proc newVkComputePipelineCreateInfo*(sType: VkStructureType = VkStructureTypeComputePipelineCreateInfo, pNext: pointer = nil, flags: VkPipelineCreateFlags = 0.VkPipelineCreateFlags, stage: VkPipelineShaderStageCreateInfo, layout: VkPipelineLayout, basePipelineHandle: VkPipeline, basePipelineIndex: int32): VkComputePipelineCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.stage = stage
  result.layout = layout
  result.basePipelineHandle = basePipelineHandle
  result.basePipelineIndex = basePipelineIndex

proc newVkVertexInputBindingDescription*(binding: uint32, stride: uint32, inputRate: VkVertexInputRate): VkVertexInputBindingDescription =
  result.binding = binding
  result.stride = stride
  result.inputRate = inputRate

proc newVkVertexInputAttributeDescription*(location: uint32, binding: uint32, format: VkFormat, offset: uint32): VkVertexInputAttributeDescription =
  result.location = location
  result.binding = binding
  result.format = format
  result.offset = offset

proc newVkPipelineVertexInputStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineVertexInputStateCreateInfo, pNext: pointer = nil, flags: VkPipelineVertexInputStateCreateFlags = 0.VkPipelineVertexInputStateCreateFlags, vertexBindingDescriptionCount: uint32, pVertexBindingDescriptions: ptr VkVertexInputBindingDescription, vertexAttributeDescriptionCount: uint32, pVertexAttributeDescriptions: ptr VkVertexInputAttributeDescription): VkPipelineVertexInputStateCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.vertexBindingDescriptionCount = vertexBindingDescriptionCount
  result.pVertexBindingDescriptions = pVertexBindingDescriptions
  result.vertexAttributeDescriptionCount = vertexAttributeDescriptionCount
  result.pVertexAttributeDescriptions = pVertexAttributeDescriptions

proc newVkPipelineInputAssemblyStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineInputAssemblyStateCreateInfo, pNext: pointer = nil, flags: VkPipelineInputAssemblyStateCreateFlags = 0.VkPipelineInputAssemblyStateCreateFlags, topology: VkPrimitiveTopology, primitiveRestartEnable: VkBool32): VkPipelineInputAssemblyStateCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.topology = topology
  result.primitiveRestartEnable = primitiveRestartEnable

proc newVkPipelineTessellationStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineTessellationStateCreateInfo, pNext: pointer = nil, flags: VkPipelineTessellationStateCreateFlags = 0.VkPipelineTessellationStateCreateFlags, patchControlPoints: uint32): VkPipelineTessellationStateCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.patchControlPoints = patchControlPoints

proc newVkPipelineViewportStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineViewportStateCreateInfo, pNext: pointer = nil, flags: VkPipelineViewportStateCreateFlags = 0.VkPipelineViewportStateCreateFlags, viewportCount: uint32, pViewports: ptr VkViewport, scissorCount: uint32, pScissors: ptr VkRect2D): VkPipelineViewportStateCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.viewportCount = viewportCount
  result.pViewports = pViewports
  result.scissorCount = scissorCount
  result.pScissors = pScissors

proc newVkPipelineRasterizationStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineRasterizationStateCreateInfo, pNext: pointer = nil, flags: VkPipelineRasterizationStateCreateFlags = 0.VkPipelineRasterizationStateCreateFlags, depthClampEnable: VkBool32, rasterizerDiscardEnable: VkBool32, polygonMode: VkPolygonMode, cullMode: VkCullModeFlags, frontFace: VkFrontFace, depthBiasEnable: VkBool32, depthBiasConstantFactor: float32, depthBiasClamp: float32, depthBiasSlopeFactor: float32, lineWidth: float32): VkPipelineRasterizationStateCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.depthClampEnable = depthClampEnable
  result.rasterizerDiscardEnable = rasterizerDiscardEnable
  result.polygonMode = polygonMode
  result.cullMode = cullMode
  result.frontFace = frontFace
  result.depthBiasEnable = depthBiasEnable
  result.depthBiasConstantFactor = depthBiasConstantFactor
  result.depthBiasClamp = depthBiasClamp
  result.depthBiasSlopeFactor = depthBiasSlopeFactor
  result.lineWidth = lineWidth

proc newVkPipelineMultisampleStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineMultisampleStateCreateInfo, pNext: pointer = nil, flags: VkPipelineMultisampleStateCreateFlags = 0.VkPipelineMultisampleStateCreateFlags, rasterizationSamples: VkSampleCountFlagBits, sampleShadingEnable: VkBool32, minSampleShading: float32, pSampleMask: ptr VkSampleMask, alphaToCoverageEnable: VkBool32, alphaToOneEnable: VkBool32): VkPipelineMultisampleStateCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.rasterizationSamples = rasterizationSamples
  result.sampleShadingEnable = sampleShadingEnable
  result.minSampleShading = minSampleShading
  result.pSampleMask = pSampleMask
  result.alphaToCoverageEnable = alphaToCoverageEnable
  result.alphaToOneEnable = alphaToOneEnable

proc newVkPipelineColorBlendAttachmentState*(blendEnable: VkBool32, srcColorBlendFactor: VkBlendFactor, dstColorBlendFactor: VkBlendFactor, colorBlendOp: VkBlendOp, srcAlphaBlendFactor: VkBlendFactor, dstAlphaBlendFactor: VkBlendFactor, alphaBlendOp: VkBlendOp, colorWriteMask: VkColorComponentFlags): VkPipelineColorBlendAttachmentState =
  result.blendEnable = blendEnable
  result.srcColorBlendFactor = srcColorBlendFactor
  result.dstColorBlendFactor = dstColorBlendFactor
  result.colorBlendOp = colorBlendOp
  result.srcAlphaBlendFactor = srcAlphaBlendFactor
  result.dstAlphaBlendFactor = dstAlphaBlendFactor
  result.alphaBlendOp = alphaBlendOp
  result.colorWriteMask = colorWriteMask

proc newVkPipelineColorBlendStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineColorBlendStateCreateInfo, pNext: pointer = nil, flags: VkPipelineColorBlendStateCreateFlags = 0.VkPipelineColorBlendStateCreateFlags, logicOpEnable: VkBool32, logicOp: VkLogicOp, attachmentCount: uint32, pAttachments: ptr VkPipelineColorBlendAttachmentState, blendConstants: array[4, float32]): VkPipelineColorBlendStateCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.logicOpEnable = logicOpEnable
  result.logicOp = logicOp
  result.attachmentCount = attachmentCount
  result.pAttachments = pAttachments
  result.blendConstants = blendConstants

proc newVkPipelineDynamicStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineDynamicStateCreateInfo, pNext: pointer = nil, flags: VkPipelineDynamicStateCreateFlags = 0.VkPipelineDynamicStateCreateFlags, dynamicStateCount: uint32, pDynamicStates: ptr VkDynamicState): VkPipelineDynamicStateCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.dynamicStateCount = dynamicStateCount
  result.pDynamicStates = pDynamicStates

proc newVkStencilOpState*(failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp, compareMask: uint32, writeMask: uint32, reference: uint32): VkStencilOpState =
  result.failOp = failOp
  result.passOp = passOp
  result.depthFailOp = depthFailOp
  result.compareOp = compareOp
  result.compareMask = compareMask
  result.writeMask = writeMask
  result.reference = reference

proc newVkPipelineDepthStencilStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineDepthStencilStateCreateInfo, pNext: pointer = nil, flags: VkPipelineDepthStencilStateCreateFlags = 0.VkPipelineDepthStencilStateCreateFlags, depthTestEnable: VkBool32, depthWriteEnable: VkBool32, depthCompareOp: VkCompareOp, depthBoundsTestEnable: VkBool32, stencilTestEnable: VkBool32, front: VkStencilOpState, back: VkStencilOpState, minDepthBounds: float32, maxDepthBounds: float32): VkPipelineDepthStencilStateCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.depthTestEnable = depthTestEnable
  result.depthWriteEnable = depthWriteEnable
  result.depthCompareOp = depthCompareOp
  result.depthBoundsTestEnable = depthBoundsTestEnable
  result.stencilTestEnable = stencilTestEnable
  result.front = front
  result.back = back
  result.minDepthBounds = minDepthBounds
  result.maxDepthBounds = maxDepthBounds

proc newVkGraphicsPipelineCreateInfo*(sType: VkStructureType = VkStructureTypeGraphicsPipelineCreateInfo, pNext: pointer = nil, flags: VkPipelineCreateFlags = 0.VkPipelineCreateFlags, stageCount: uint32, pStages: ptr VkPipelineShaderStageCreateInfo, pVertexInputState: ptr VkPipelineVertexInputStateCreateInfo, pInputAssemblyState: ptr VkPipelineInputAssemblyStateCreateInfo, pTessellationState: ptr VkPipelineTessellationStateCreateInfo, pViewportState: ptr VkPipelineViewportStateCreateInfo, pRasterizationState: ptr VkPipelineRasterizationStateCreateInfo, pMultisampleState: ptr VkPipelineMultisampleStateCreateInfo, pDepthStencilState: ptr VkPipelineDepthStencilStateCreateInfo, pColorBlendState: ptr VkPipelineColorBlendStateCreateInfo, pDynamicState: ptr VkPipelineDynamicStateCreateInfo, layout: VkPipelineLayout, renderPass: VkRenderPass, subpass: uint32, basePipelineHandle: VkPipeline, basePipelineIndex: int32): VkGraphicsPipelineCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.stageCount = stageCount
  result.pStages = pStages
  result.pVertexInputState = pVertexInputState
  result.pInputAssemblyState = pInputAssemblyState
  result.pTessellationState = pTessellationState
  result.pViewportState = pViewportState
  result.pRasterizationState = pRasterizationState
  result.pMultisampleState = pMultisampleState
  result.pDepthStencilState = pDepthStencilState
  result.pColorBlendState = pColorBlendState
  result.pDynamicState = pDynamicState
  result.layout = layout
  result.renderPass = renderPass
  result.subpass = subpass
  result.basePipelineHandle = basePipelineHandle
  result.basePipelineIndex = basePipelineIndex

proc newVkPipelineCacheCreateInfo*(sType: VkStructureType = VkStructureTypePipelineCacheCreateInfo, pNext: pointer = nil, flags: VkPipelineCacheCreateFlags = 0.VkPipelineCacheCreateFlags, initialDataSize: uint, pInitialData: pointer = nil): VkPipelineCacheCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.initialDataSize = initialDataSize
  result.pInitialData = pInitialData

proc newVkPushConstantRange*(stageFlags: VkShaderStageFlags, offset: uint32, size: uint32): VkPushConstantRange =
  result.stageFlags = stageFlags
  result.offset = offset
  result.size = size

proc newVkPipelineLayoutCreateInfo*(sType: VkStructureType = VkStructureTypePipelineLayoutCreateInfo, pNext: pointer = nil, flags: VkPipelineLayoutCreateFlags = 0.VkPipelineLayoutCreateFlags, setLayoutCount: uint32, pSetLayouts: ptr VkDescriptorSetLayout, pushConstantRangeCount: uint32, pPushConstantRanges: ptr VkPushConstantRange): VkPipelineLayoutCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.setLayoutCount = setLayoutCount
  result.pSetLayouts = pSetLayouts
  result.pushConstantRangeCount = pushConstantRangeCount
  result.pPushConstantRanges = pPushConstantRanges

proc newVkSamplerCreateInfo*(sType: VkStructureType = VkStructureTypeSamplerCreateInfo, pNext: pointer = nil, flags: VkSamplerCreateFlags = 0.VkSamplerCreateFlags, magFilter: VkFilter, minFilter: VkFilter, mipmapMode: VkSamplerMipmapMode, addressModeU: VkSamplerAddressMode, addressModeV: VkSamplerAddressMode, addressModeW: VkSamplerAddressMode, mipLodBias: float32, anisotropyEnable: VkBool32, maxAnisotropy: float32, compareEnable: VkBool32, compareOp: VkCompareOp, minLod: float32, maxLod: float32, borderColor: VkBorderColor, unnormalizedCoordinates: VkBool32): VkSamplerCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.magFilter = magFilter
  result.minFilter = minFilter
  result.mipmapMode = mipmapMode
  result.addressModeU = addressModeU
  result.addressModeV = addressModeV
  result.addressModeW = addressModeW
  result.mipLodBias = mipLodBias
  result.anisotropyEnable = anisotropyEnable
  result.maxAnisotropy = maxAnisotropy
  result.compareEnable = compareEnable
  result.compareOp = compareOp
  result.minLod = minLod
  result.maxLod = maxLod
  result.borderColor = borderColor
  result.unnormalizedCoordinates = unnormalizedCoordinates

proc newVkCommandPoolCreateInfo*(sType: VkStructureType = VkStructureTypeCommandPoolCreateInfo, pNext: pointer = nil, flags: VkCommandPoolCreateFlags = 0.VkCommandPoolCreateFlags, queueFamilyIndex: uint32): VkCommandPoolCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.queueFamilyIndex = queueFamilyIndex

proc newVkCommandBufferAllocateInfo*(sType: VkStructureType = VkStructureTypeCommandBufferAllocateInfo, pNext: pointer = nil, commandPool: VkCommandPool, level: VkCommandBufferLevel, commandBufferCount: uint32): VkCommandBufferAllocateInfo =
  result.sType = sType
  result.pNext = pNext
  result.commandPool = commandPool
  result.level = level
  result.commandBufferCount = commandBufferCount

proc newVkCommandBufferInheritanceInfo*(sType: VkStructureType = VkStructureTypeCommandBufferInheritanceInfo, pNext: pointer = nil, renderPass: VkRenderPass, subpass: uint32, framebuffer: VkFramebuffer, occlusionQueryEnable: VkBool32, queryFlags: VkQueryControlFlags, pipelineStatistics: VkQueryPipelineStatisticFlags): VkCommandBufferInheritanceInfo =
  result.sType = sType
  result.pNext = pNext
  result.renderPass = renderPass
  result.subpass = subpass
  result.framebuffer = framebuffer
  result.occlusionQueryEnable = occlusionQueryEnable
  result.queryFlags = queryFlags
  result.pipelineStatistics = pipelineStatistics

proc newVkCommandBufferBeginInfo*(sType: VkStructureType = VkStructureTypeCommandBufferBeginInfo, pNext: pointer = nil, flags: VkCommandBufferUsageFlags = 0.VkCommandBufferUsageFlags, pInheritanceInfo: ptr VkCommandBufferInheritanceInfo): VkCommandBufferBeginInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.pInheritanceInfo = pInheritanceInfo

proc newVkRenderPassBeginInfo*(sType: VkStructureType = VkStructureTypeRenderPassBeginInfo, pNext: pointer = nil, renderPass: VkRenderPass, framebuffer: VkFramebuffer, renderArea: VkRect2D, clearValueCount: uint32, pClearValues: ptr VkClearValue): VkRenderPassBeginInfo =
  result.sType = sType
  result.pNext = pNext
  result.renderPass = renderPass
  result.framebuffer = framebuffer
  result.renderArea = renderArea
  result.clearValueCount = clearValueCount
  result.pClearValues = pClearValues

proc newVkClearDepthStencilValue*(depth: float32, stencil: uint32): VkClearDepthStencilValue =
  result.depth = depth
  result.stencil = stencil

proc newVkClearAttachment*(aspectMask: VkImageAspectFlags, colorAttachment: uint32, clearValue: VkClearValue): VkClearAttachment =
  result.aspectMask = aspectMask
  result.colorAttachment = colorAttachment
  result.clearValue = clearValue

proc newVkAttachmentDescription*(flags: VkAttachmentDescriptionFlags = 0.VkAttachmentDescriptionFlags, format: VkFormat, samples: VkSampleCountFlagBits, loadOp: VkAttachmentLoadOp, storeOp: VkAttachmentStoreOp, stencilLoadOp: VkAttachmentLoadOp, stencilStoreOp: VkAttachmentStoreOp, initialLayout: VkImageLayout, finalLayout: VkImageLayout): VkAttachmentDescription =
  result.flags = flags
  result.format = format
  result.samples = samples
  result.loadOp = loadOp
  result.storeOp = storeOp
  result.stencilLoadOp = stencilLoadOp
  result.stencilStoreOp = stencilStoreOp
  result.initialLayout = initialLayout
  result.finalLayout = finalLayout

proc newVkAttachmentReference*(attachment: uint32, layout: VkImageLayout): VkAttachmentReference =
  result.attachment = attachment
  result.layout = layout

proc newVkSubpassDescription*(flags: VkSubpassDescriptionFlags = 0.VkSubpassDescriptionFlags, pipelineBindPoint: VkPipelineBindPoint, inputAttachmentCount: uint32, pInputAttachments: ptr VkAttachmentReference, colorAttachmentCount: uint32, pColorAttachments: ptr VkAttachmentReference, pResolveAttachments: ptr VkAttachmentReference, pDepthStencilAttachment: ptr VkAttachmentReference, preserveAttachmentCount: uint32, pPreserveAttachments: ptr uint32): VkSubpassDescription =
  result.flags = flags
  result.pipelineBindPoint = pipelineBindPoint
  result.inputAttachmentCount = inputAttachmentCount
  result.pInputAttachments = pInputAttachments
  result.colorAttachmentCount = colorAttachmentCount
  result.pColorAttachments = pColorAttachments
  result.pResolveAttachments = pResolveAttachments
  result.pDepthStencilAttachment = pDepthStencilAttachment
  result.preserveAttachmentCount = preserveAttachmentCount
  result.pPreserveAttachments = pPreserveAttachments

proc newVkSubpassDependency*(srcSubpass: uint32, dstSubpass: uint32, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, srcAccessMask: VkAccessFlags, dstAccessMask: VkAccessFlags, dependencyFlags: VkDependencyFlags): VkSubpassDependency =
  result.srcSubpass = srcSubpass
  result.dstSubpass = dstSubpass
  result.srcStageMask = srcStageMask
  result.dstStageMask = dstStageMask
  result.srcAccessMask = srcAccessMask
  result.dstAccessMask = dstAccessMask
  result.dependencyFlags = dependencyFlags

proc newVkRenderPassCreateInfo*(sType: VkStructureType = VkStructureTypeRenderPassCreateInfo, pNext: pointer = nil, flags: VkRenderPassCreateFlags = 0.VkRenderPassCreateFlags, attachmentCount: uint32, pAttachments: ptr VkAttachmentDescription, subpassCount: uint32, pSubpasses: ptr VkSubpassDescription, dependencyCount: uint32, pDependencies: ptr VkSubpassDependency): VkRenderPassCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.attachmentCount = attachmentCount
  result.pAttachments = pAttachments
  result.subpassCount = subpassCount
  result.pSubpasses = pSubpasses
  result.dependencyCount = dependencyCount
  result.pDependencies = pDependencies

proc newVkEventCreateInfo*(sType: VkStructureType = VkStructureTypeEventCreateInfo, pNext: pointer = nil, flags: VkEventCreateFlags = 0.VkEventCreateFlags): VkEventCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags

proc newVkFenceCreateInfo*(sType: VkStructureType = VkStructureTypeFenceCreateInfo, pNext: pointer = nil, flags: VkFenceCreateFlags = 0.VkFenceCreateFlags): VkFenceCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags

proc newVkPhysicalDeviceFeatures*(robustBufferAccess: VkBool32, fullDrawIndexUint32: VkBool32, imageCubeArray: VkBool32, independentBlend: VkBool32, geometryShader: VkBool32, tessellationShader: VkBool32, sampleRateShading: VkBool32, dualSrcBlend: VkBool32, logicOp: VkBool32, multiDrawIndirect: VkBool32, drawIndirectFirstInstance: VkBool32, depthClamp: VkBool32, depthBiasClamp: VkBool32, fillModeNonSolid: VkBool32, depthBounds: VkBool32, wideLines: VkBool32, largePoints: VkBool32, alphaToOne: VkBool32, multiViewport: VkBool32, samplerAnisotropy: VkBool32, textureCompressionETC2: VkBool32, textureCompressionASTC_LDR: VkBool32, textureCompressionBC: VkBool32, occlusionQueryPrecise: VkBool32, pipelineStatisticsQuery: VkBool32, vertexPipelineStoresAndAtomics: VkBool32, fragmentStoresAndAtomics: VkBool32, shaderTessellationAndGeometryPointSize: VkBool32, shaderImageGatherExtended: VkBool32, shaderStorageImageExtendedFormats: VkBool32, shaderStorageImageMultisample: VkBool32, shaderStorageImageReadWithoutFormat: VkBool32, shaderStorageImageWriteWithoutFormat: VkBool32, shaderUniformBufferArrayDynamicIndexing: VkBool32, shaderSampledImageArrayDynamicIndexing: VkBool32, shaderStorageBufferArrayDynamicIndexing: VkBool32, shaderStorageImageArrayDynamicIndexing: VkBool32, shaderClipDistance: VkBool32, shaderCullDistance: VkBool32, shaderFloat64: VkBool32, shaderInt64: VkBool32, shaderInt16: VkBool32, shaderResourceResidency: VkBool32, shaderResourceMinLod: VkBool32, sparseBinding: VkBool32, sparseResidencyBuffer: VkBool32, sparseResidencyImage2D: VkBool32, sparseResidencyImage3D: VkBool32, sparseResidency2Samples: VkBool32, sparseResidency4Samples: VkBool32, sparseResidency8Samples: VkBool32, sparseResidency16Samples: VkBool32, sparseResidencyAliased: VkBool32, variableMultisampleRate: VkBool32, inheritedQueries: VkBool32): VkPhysicalDeviceFeatures =
  result.robustBufferAccess = robustBufferAccess
  result.fullDrawIndexUint32 = fullDrawIndexUint32
  result.imageCubeArray = imageCubeArray
  result.independentBlend = independentBlend
  result.geometryShader = geometryShader
  result.tessellationShader = tessellationShader
  result.sampleRateShading = sampleRateShading
  result.dualSrcBlend = dualSrcBlend
  result.logicOp = logicOp
  result.multiDrawIndirect = multiDrawIndirect
  result.drawIndirectFirstInstance = drawIndirectFirstInstance
  result.depthClamp = depthClamp
  result.depthBiasClamp = depthBiasClamp
  result.fillModeNonSolid = fillModeNonSolid
  result.depthBounds = depthBounds
  result.wideLines = wideLines
  result.largePoints = largePoints
  result.alphaToOne = alphaToOne
  result.multiViewport = multiViewport
  result.samplerAnisotropy = samplerAnisotropy
  result.textureCompressionETC2 = textureCompressionETC2
  result.textureCompressionASTC_LDR = textureCompressionASTC_LDR
  result.textureCompressionBC = textureCompressionBC
  result.occlusionQueryPrecise = occlusionQueryPrecise
  result.pipelineStatisticsQuery = pipelineStatisticsQuery
  result.vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics
  result.fragmentStoresAndAtomics = fragmentStoresAndAtomics
  result.shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize
  result.shaderImageGatherExtended = shaderImageGatherExtended
  result.shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats
  result.shaderStorageImageMultisample = shaderStorageImageMultisample
  result.shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat
  result.shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat
  result.shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing
  result.shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing
  result.shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing
  result.shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing
  result.shaderClipDistance = shaderClipDistance
  result.shaderCullDistance = shaderCullDistance
  result.shaderFloat64 = shaderFloat64
  result.shaderInt64 = shaderInt64
  result.shaderInt16 = shaderInt16
  result.shaderResourceResidency = shaderResourceResidency
  result.shaderResourceMinLod = shaderResourceMinLod
  result.sparseBinding = sparseBinding
  result.sparseResidencyBuffer = sparseResidencyBuffer
  result.sparseResidencyImage2D = sparseResidencyImage2D
  result.sparseResidencyImage3D = sparseResidencyImage3D
  result.sparseResidency2Samples = sparseResidency2Samples
  result.sparseResidency4Samples = sparseResidency4Samples
  result.sparseResidency8Samples = sparseResidency8Samples
  result.sparseResidency16Samples = sparseResidency16Samples
  result.sparseResidencyAliased = sparseResidencyAliased
  result.variableMultisampleRate = variableMultisampleRate
  result.inheritedQueries = inheritedQueries

proc newVkPhysicalDeviceSparseProperties*(residencyStandard2DBlockShape: VkBool32, residencyStandard2DMultisampleBlockShape: VkBool32, residencyStandard3DBlockShape: VkBool32, residencyAlignedMipSize: VkBool32, residencyNonResidentStrict: VkBool32): VkPhysicalDeviceSparseProperties =
  result.residencyStandard2DBlockShape = residencyStandard2DBlockShape
  result.residencyStandard2DMultisampleBlockShape = residencyStandard2DMultisampleBlockShape
  result.residencyStandard3DBlockShape = residencyStandard3DBlockShape
  result.residencyAlignedMipSize = residencyAlignedMipSize
  result.residencyNonResidentStrict = residencyNonResidentStrict

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

proc newVkSemaphoreCreateInfo*(sType: VkStructureType = VkStructureTypeSemaphoreCreateInfo, pNext: pointer = nil, flags: VkSemaphoreCreateFlags = 0.VkSemaphoreCreateFlags): VkSemaphoreCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags

proc newVkQueryPoolCreateInfo*(sType: VkStructureType = VkStructureTypeQueryPoolCreateInfo, pNext: pointer = nil, flags: VkQueryPoolCreateFlags = 0.VkQueryPoolCreateFlags, queryType: VkQueryType, queryCount: uint32, pipelineStatistics: VkQueryPipelineStatisticFlags): VkQueryPoolCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.queryType = queryType
  result.queryCount = queryCount
  result.pipelineStatistics = pipelineStatistics

proc newVkFramebufferCreateInfo*(sType: VkStructureType = VkStructureTypeFramebufferCreateInfo, pNext: pointer = nil, flags: VkFramebufferCreateFlags = 0.VkFramebufferCreateFlags, renderPass: VkRenderPass, attachmentCount: uint32, pAttachments: ptr VkImageView, width: uint32, height: uint32, layers: uint32): VkFramebufferCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.renderPass = renderPass
  result.attachmentCount = attachmentCount
  result.pAttachments = pAttachments
  result.width = width
  result.height = height
  result.layers = layers

proc newVkDrawIndirectCommand*(vertexCount: uint32, instanceCount: uint32, firstVertex: uint32, firstInstance: uint32): VkDrawIndirectCommand =
  result.vertexCount = vertexCount
  result.instanceCount = instanceCount
  result.firstVertex = firstVertex
  result.firstInstance = firstInstance

proc newVkDrawIndexedIndirectCommand*(indexCount: uint32, instanceCount: uint32, firstIndex: uint32, vertexOffset: int32, firstInstance: uint32): VkDrawIndexedIndirectCommand =
  result.indexCount = indexCount
  result.instanceCount = instanceCount
  result.firstIndex = firstIndex
  result.vertexOffset = vertexOffset
  result.firstInstance = firstInstance

proc newVkDispatchIndirectCommand*(x: uint32, y: uint32, z: uint32): VkDispatchIndirectCommand =
  result.x = x
  result.y = y
  result.z = z

proc newVkSubmitInfo*(sType: VkStructureType = VkStructureTypeSubmitInfo, pNext: pointer = nil, waitSemaphoreCount: uint32, pWaitSemaphores: ptr VkSemaphore, pWaitDstStageMask: ptr VkPipelineStageFlags, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer, signalSemaphoreCount: uint32, pSignalSemaphores: ptr VkSemaphore): VkSubmitInfo =
  result.sType = sType
  result.pNext = pNext
  result.waitSemaphoreCount = waitSemaphoreCount
  result.pWaitSemaphores = pWaitSemaphores
  result.pWaitDstStageMask = pWaitDstStageMask
  result.commandBufferCount = commandBufferCount
  result.pCommandBuffers = pCommandBuffers
  result.signalSemaphoreCount = signalSemaphoreCount
  result.pSignalSemaphores = pSignalSemaphores

proc newVkDisplayPropertiesKHR*(display: VkDisplayKHR, displayName: cstring, physicalDimensions: VkExtent2D, physicalResolution: VkExtent2D, supportedTransforms: VkSurfaceTransformFlagsKHR, planeReorderPossible: VkBool32, persistentContent: VkBool32): VkDisplayPropertiesKHR =
  result.display = display
  result.displayName = displayName
  result.physicalDimensions = physicalDimensions
  result.physicalResolution = physicalResolution
  result.supportedTransforms = supportedTransforms
  result.planeReorderPossible = planeReorderPossible
  result.persistentContent = persistentContent

proc newVkDisplayPlanePropertiesKHR*(currentDisplay: VkDisplayKHR, currentStackIndex: uint32): VkDisplayPlanePropertiesKHR =
  result.currentDisplay = currentDisplay
  result.currentStackIndex = currentStackIndex

proc newVkDisplayModeParametersKHR*(visibleRegion: VkExtent2D, refreshRate: uint32): VkDisplayModeParametersKHR =
  result.visibleRegion = visibleRegion
  result.refreshRate = refreshRate

proc newVkDisplayModePropertiesKHR*(displayMode: VkDisplayModeKHR, parameters: VkDisplayModeParametersKHR): VkDisplayModePropertiesKHR =
  result.displayMode = displayMode
  result.parameters = parameters

proc newVkDisplayModeCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkDisplayModeCreateFlagsKHR = 0.VkDisplayModeCreateFlagsKHR, parameters: VkDisplayModeParametersKHR): VkDisplayModeCreateInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.parameters = parameters

proc newVkDisplayPlaneCapabilitiesKHR*(supportedAlpha: VkDisplayPlaneAlphaFlagsKHR, minSrcPosition: VkOffset2D, maxSrcPosition: VkOffset2D, minSrcExtent: VkExtent2D, maxSrcExtent: VkExtent2D, minDstPosition: VkOffset2D, maxDstPosition: VkOffset2D, minDstExtent: VkExtent2D, maxDstExtent: VkExtent2D): VkDisplayPlaneCapabilitiesKHR =
  result.supportedAlpha = supportedAlpha
  result.minSrcPosition = minSrcPosition
  result.maxSrcPosition = maxSrcPosition
  result.minSrcExtent = minSrcExtent
  result.maxSrcExtent = maxSrcExtent
  result.minDstPosition = minDstPosition
  result.maxDstPosition = maxDstPosition
  result.minDstExtent = minDstExtent
  result.maxDstExtent = maxDstExtent

proc newVkDisplaySurfaceCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkDisplaySurfaceCreateFlagsKHR = 0.VkDisplaySurfaceCreateFlagsKHR, displayMode: VkDisplayModeKHR, planeIndex: uint32, planeStackIndex: uint32, transform: VkSurfaceTransformFlagBitsKHR, globalAlpha: float32, alphaMode: VkDisplayPlaneAlphaFlagBitsKHR, imageExtent: VkExtent2D): VkDisplaySurfaceCreateInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.displayMode = displayMode
  result.planeIndex = planeIndex
  result.planeStackIndex = planeStackIndex
  result.transform = transform
  result.globalAlpha = globalAlpha
  result.alphaMode = alphaMode
  result.imageExtent = imageExtent

proc newVkDisplayPresentInfoKHR*(sType: VkStructureType, pNext: pointer = nil, srcRect: VkRect2D, dstRect: VkRect2D, persistent: VkBool32): VkDisplayPresentInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.srcRect = srcRect
  result.dstRect = dstRect
  result.persistent = persistent

proc newVkSurfaceCapabilitiesKHR*(minImageCount: uint32, maxImageCount: uint32, currentExtent: VkExtent2D, minImageExtent: VkExtent2D, maxImageExtent: VkExtent2D, maxImageArrayLayers: uint32, supportedTransforms: VkSurfaceTransformFlagsKHR, currentTransform: VkSurfaceTransformFlagBitsKHR, supportedCompositeAlpha: VkCompositeAlphaFlagsKHR, supportedUsageFlags: VkImageUsageFlags): VkSurfaceCapabilitiesKHR =
  result.minImageCount = minImageCount
  result.maxImageCount = maxImageCount
  result.currentExtent = currentExtent
  result.minImageExtent = minImageExtent
  result.maxImageExtent = maxImageExtent
  result.maxImageArrayLayers = maxImageArrayLayers
  result.supportedTransforms = supportedTransforms
  result.currentTransform = currentTransform
  result.supportedCompositeAlpha = supportedCompositeAlpha
  result.supportedUsageFlags = supportedUsageFlags

proc newVkAndroidSurfaceCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkAndroidSurfaceCreateFlagsKHR = 0.VkAndroidSurfaceCreateFlagsKHR, window: ptr ANativeWindow): VkAndroidSurfaceCreateInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.window = window

proc newVkViSurfaceCreateInfoNN*(sType: VkStructureType, pNext: pointer = nil, flags: VkViSurfaceCreateFlagsNN = 0.VkViSurfaceCreateFlagsNN, window: pointer = nil): VkViSurfaceCreateInfoNN =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.window = window

proc newVkWaylandSurfaceCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkWaylandSurfaceCreateFlagsKHR = 0.VkWaylandSurfaceCreateFlagsKHR, display: ptr wl_display, surface: ptr wl_surface): VkWaylandSurfaceCreateInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.display = display
  result.surface = surface

proc newVkWin32SurfaceCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkWin32SurfaceCreateFlagsKHR = 0.VkWin32SurfaceCreateFlagsKHR, hinstance: HINSTANCE, hwnd: HWND): VkWin32SurfaceCreateInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.hinstance = hinstance
  result.hwnd = hwnd

proc newVkXlibSurfaceCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkXlibSurfaceCreateFlagsKHR = 0.VkXlibSurfaceCreateFlagsKHR, dpy: ptr Display, window: Window): VkXlibSurfaceCreateInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.dpy = dpy
  result.window = window

proc newVkXcbSurfaceCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkXcbSurfaceCreateFlagsKHR = 0.VkXcbSurfaceCreateFlagsKHR, connection: ptr xcb_connection_t, window: xcb_window_t): VkXcbSurfaceCreateInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.connection = connection
  result.window = window

proc newVkDirectFBSurfaceCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkDirectFBSurfaceCreateFlagsEXT = 0.VkDirectFBSurfaceCreateFlagsEXT, dfb: ptr IDirectFB, surface: ptr IDirectFBSurface): VkDirectFBSurfaceCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.dfb = dfb
  result.surface = surface

proc newVkImagePipeSurfaceCreateInfoFUCHSIA*(sType: VkStructureType, pNext: pointer = nil, flags: VkImagePipeSurfaceCreateFlagsFUCHSIA = 0.VkImagePipeSurfaceCreateFlagsFUCHSIA, imagePipeHandle: zx_handle_t): VkImagePipeSurfaceCreateInfoFUCHSIA =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.imagePipeHandle = imagePipeHandle

proc newVkStreamDescriptorSurfaceCreateInfoGGP*(sType: VkStructureType, pNext: pointer = nil, flags: VkStreamDescriptorSurfaceCreateFlagsGGP = 0.VkStreamDescriptorSurfaceCreateFlagsGGP, streamDescriptor: GgpStreamDescriptor): VkStreamDescriptorSurfaceCreateInfoGGP =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.streamDescriptor = streamDescriptor

proc newVkSurfaceFormatKHR*(format: VkFormat, colorSpace: VkColorSpaceKHR): VkSurfaceFormatKHR =
  result.format = format
  result.colorSpace = colorSpace

proc newVkSwapchainCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkSwapchainCreateFlagsKHR = 0.VkSwapchainCreateFlagsKHR, surface: VkSurfaceKHR, minImageCount: uint32, imageFormat: VkFormat, imageColorSpace: VkColorSpaceKHR, imageExtent: VkExtent2D, imageArrayLayers: uint32, imageUsage: VkImageUsageFlags, imageSharingMode: VkSharingMode, queueFamilyIndexCount: uint32, pQueueFamilyIndices: ptr uint32, preTransform: VkSurfaceTransformFlagBitsKHR, compositeAlpha: VkCompositeAlphaFlagBitsKHR, presentMode: VkPresentModeKHR, clipped: VkBool32, oldSwapchain: VkSwapchainKHR): VkSwapchainCreateInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.surface = surface
  result.minImageCount = minImageCount
  result.imageFormat = imageFormat
  result.imageColorSpace = imageColorSpace
  result.imageExtent = imageExtent
  result.imageArrayLayers = imageArrayLayers
  result.imageUsage = imageUsage
  result.imageSharingMode = imageSharingMode
  result.queueFamilyIndexCount = queueFamilyIndexCount
  result.pQueueFamilyIndices = pQueueFamilyIndices
  result.preTransform = preTransform
  result.compositeAlpha = compositeAlpha
  result.presentMode = presentMode
  result.clipped = clipped
  result.oldSwapchain = oldSwapchain

proc newVkPresentInfoKHR*(sType: VkStructureType, pNext: pointer = nil, waitSemaphoreCount: uint32, pWaitSemaphores: ptr VkSemaphore, swapchainCount: uint32, pSwapchains: ptr VkSwapchainKHR, pImageIndices: ptr uint32, pResults: ptr VkResult): VkPresentInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.waitSemaphoreCount = waitSemaphoreCount
  result.pWaitSemaphores = pWaitSemaphores
  result.swapchainCount = swapchainCount
  result.pSwapchains = pSwapchains
  result.pImageIndices = pImageIndices
  result.pResults = pResults

proc newVkDebugReportCallbackCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkDebugReportFlagsEXT = 0.VkDebugReportFlagsEXT, pfnCallback: PFN_vkDebugReportCallbackEXT, pUserData: pointer = nil): VkDebugReportCallbackCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.pfnCallback = pfnCallback
  result.pUserData = pUserData

proc newVkValidationFlagsEXT*(sType: VkStructureType, pNext: pointer = nil, disabledValidationCheckCount: uint32, pDisabledValidationChecks: ptr VkValidationCheckEXT): VkValidationFlagsEXT =
  result.sType = sType
  result.pNext = pNext
  result.disabledValidationCheckCount = disabledValidationCheckCount
  result.pDisabledValidationChecks = pDisabledValidationChecks

proc newVkValidationFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, enabledValidationFeatureCount: uint32, pEnabledValidationFeatures: ptr VkValidationFeatureEnableEXT, disabledValidationFeatureCount: uint32, pDisabledValidationFeatures: ptr VkValidationFeatureDisableEXT): VkValidationFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.enabledValidationFeatureCount = enabledValidationFeatureCount
  result.pEnabledValidationFeatures = pEnabledValidationFeatures
  result.disabledValidationFeatureCount = disabledValidationFeatureCount
  result.pDisabledValidationFeatures = pDisabledValidationFeatures

proc newVkPipelineRasterizationStateRasterizationOrderAMD*(sType: VkStructureType, pNext: pointer = nil, rasterizationOrder: VkRasterizationOrderAMD): VkPipelineRasterizationStateRasterizationOrderAMD =
  result.sType = sType
  result.pNext = pNext
  result.rasterizationOrder = rasterizationOrder

proc newVkDebugMarkerObjectNameInfoEXT*(sType: VkStructureType, pNext: pointer = nil, objectType: VkDebugReportObjectTypeEXT, `object`: uint64, pObjectName: cstring): VkDebugMarkerObjectNameInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.objectType = objectType
  result.`object` = `object`
  result.pObjectName = pObjectName

proc newVkDebugMarkerObjectTagInfoEXT*(sType: VkStructureType, pNext: pointer = nil, objectType: VkDebugReportObjectTypeEXT, `object`: uint64, tagName: uint64, tagSize: uint, pTag: pointer = nil): VkDebugMarkerObjectTagInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.objectType = objectType
  result.`object` = `object`
  result.tagName = tagName
  result.tagSize = tagSize
  result.pTag = pTag

proc newVkDebugMarkerMarkerInfoEXT*(sType: VkStructureType, pNext: pointer = nil, pMarkerName: cstring, color: array[4, float32]): VkDebugMarkerMarkerInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.pMarkerName = pMarkerName
  result.color = color

proc newVkDedicatedAllocationImageCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, dedicatedAllocation: VkBool32): VkDedicatedAllocationImageCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.dedicatedAllocation = dedicatedAllocation

proc newVkDedicatedAllocationBufferCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, dedicatedAllocation: VkBool32): VkDedicatedAllocationBufferCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.dedicatedAllocation = dedicatedAllocation

proc newVkDedicatedAllocationMemoryAllocateInfoNV*(sType: VkStructureType, pNext: pointer = nil, image: VkImage, buffer: VkBuffer): VkDedicatedAllocationMemoryAllocateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.image = image
  result.buffer = buffer

proc newVkExternalImageFormatPropertiesNV*(imageFormatProperties: VkImageFormatProperties, externalMemoryFeatures: VkExternalMemoryFeatureFlagsNV, exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlagsNV, compatibleHandleTypes: VkExternalMemoryHandleTypeFlagsNV): VkExternalImageFormatPropertiesNV =
  result.imageFormatProperties = imageFormatProperties
  result.externalMemoryFeatures = externalMemoryFeatures
  result.exportFromImportedHandleTypes = exportFromImportedHandleTypes
  result.compatibleHandleTypes = compatibleHandleTypes

proc newVkExternalMemoryImageCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, handleTypes: VkExternalMemoryHandleTypeFlagsNV): VkExternalMemoryImageCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.handleTypes = handleTypes

proc newVkExportMemoryAllocateInfoNV*(sType: VkStructureType, pNext: pointer = nil, handleTypes: VkExternalMemoryHandleTypeFlagsNV): VkExportMemoryAllocateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.handleTypes = handleTypes

proc newVkImportMemoryWin32HandleInfoNV*(sType: VkStructureType, pNext: pointer = nil, handleType: VkExternalMemoryHandleTypeFlagsNV, handle: HANDLE): VkImportMemoryWin32HandleInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.handleType = handleType
  result.handle = handle

proc newVkExportMemoryWin32HandleInfoNV*(sType: VkStructureType, pNext: pointer = nil, pAttributes: ptr SECURITY_ATTRIBUTES, dwAccess: DWORD): VkExportMemoryWin32HandleInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.pAttributes = pAttributes
  result.dwAccess = dwAccess

proc newVkWin32KeyedMutexAcquireReleaseInfoNV*(sType: VkStructureType, pNext: pointer = nil, acquireCount: uint32, pAcquireSyncs: ptr VkDeviceMemory, pAcquireKeys: ptr uint64, pAcquireTimeoutMilliseconds: ptr uint32, releaseCount: uint32, pReleaseSyncs: ptr VkDeviceMemory, pReleaseKeys: ptr uint64): VkWin32KeyedMutexAcquireReleaseInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.acquireCount = acquireCount
  result.pAcquireSyncs = pAcquireSyncs
  result.pAcquireKeys = pAcquireKeys
  result.pAcquireTimeoutMilliseconds = pAcquireTimeoutMilliseconds
  result.releaseCount = releaseCount
  result.pReleaseSyncs = pReleaseSyncs
  result.pReleaseKeys = pReleaseKeys

proc newVkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, deviceGeneratedCommands: VkBool32): VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV =
  result.sType = sType
  result.pNext = pNext
  result.deviceGeneratedCommands = deviceGeneratedCommands

proc newVkDevicePrivateDataCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, privateDataSlotRequestCount: uint32): VkDevicePrivateDataCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.privateDataSlotRequestCount = privateDataSlotRequestCount

proc newVkPrivateDataSlotCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkPrivateDataSlotCreateFlagsEXT = 0.VkPrivateDataSlotCreateFlagsEXT): VkPrivateDataSlotCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags

proc newVkPhysicalDevicePrivateDataFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, privateData: VkBool32): VkPhysicalDevicePrivateDataFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.privateData = privateData

proc newVkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*(sType: VkStructureType, pNext: pointer = nil, maxGraphicsShaderGroupCount: uint32, maxIndirectSequenceCount: uint32, maxIndirectCommandsTokenCount: uint32, maxIndirectCommandsStreamCount: uint32, maxIndirectCommandsTokenOffset: uint32, maxIndirectCommandsStreamStride: uint32, minSequencesCountBufferOffsetAlignment: uint32, minSequencesIndexBufferOffsetAlignment: uint32, minIndirectCommandsBufferOffsetAlignment: uint32): VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV =
  result.sType = sType
  result.pNext = pNext
  result.maxGraphicsShaderGroupCount = maxGraphicsShaderGroupCount
  result.maxIndirectSequenceCount = maxIndirectSequenceCount
  result.maxIndirectCommandsTokenCount = maxIndirectCommandsTokenCount
  result.maxIndirectCommandsStreamCount = maxIndirectCommandsStreamCount
  result.maxIndirectCommandsTokenOffset = maxIndirectCommandsTokenOffset
  result.maxIndirectCommandsStreamStride = maxIndirectCommandsStreamStride
  result.minSequencesCountBufferOffsetAlignment = minSequencesCountBufferOffsetAlignment
  result.minSequencesIndexBufferOffsetAlignment = minSequencesIndexBufferOffsetAlignment
  result.minIndirectCommandsBufferOffsetAlignment = minIndirectCommandsBufferOffsetAlignment

proc newVkGraphicsShaderGroupCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, stageCount: uint32, pStages: ptr VkPipelineShaderStageCreateInfo, pVertexInputState: ptr VkPipelineVertexInputStateCreateInfo, pTessellationState: ptr VkPipelineTessellationStateCreateInfo): VkGraphicsShaderGroupCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.stageCount = stageCount
  result.pStages = pStages
  result.pVertexInputState = pVertexInputState
  result.pTessellationState = pTessellationState

proc newVkGraphicsPipelineShaderGroupsCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, groupCount: uint32, pGroups: ptr VkGraphicsShaderGroupCreateInfoNV, pipelineCount: uint32, pPipelines: ptr VkPipeline): VkGraphicsPipelineShaderGroupsCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.groupCount = groupCount
  result.pGroups = pGroups
  result.pipelineCount = pipelineCount
  result.pPipelines = pPipelines

proc newVkBindShaderGroupIndirectCommandNV*(groupIndex: uint32): VkBindShaderGroupIndirectCommandNV =
  result.groupIndex = groupIndex

proc newVkBindIndexBufferIndirectCommandNV*(bufferAddress: VkDeviceAddress, size: uint32, indexType: VkIndexType): VkBindIndexBufferIndirectCommandNV =
  result.bufferAddress = bufferAddress
  result.size = size
  result.indexType = indexType

proc newVkBindVertexBufferIndirectCommandNV*(bufferAddress: VkDeviceAddress, size: uint32, stride: uint32): VkBindVertexBufferIndirectCommandNV =
  result.bufferAddress = bufferAddress
  result.size = size
  result.stride = stride

proc newVkSetStateFlagsIndirectCommandNV*(data: uint32): VkSetStateFlagsIndirectCommandNV =
  result.data = data

proc newVkIndirectCommandsStreamNV*(buffer: VkBuffer, offset: VkDeviceSize): VkIndirectCommandsStreamNV =
  result.buffer = buffer
  result.offset = offset

proc newVkIndirectCommandsLayoutTokenNV*(sType: VkStructureType, pNext: pointer = nil, tokenType: VkIndirectCommandsTokenTypeNV, stream: uint32, offset: uint32, vertexBindingUnit: uint32, vertexDynamicStride: VkBool32, pushconstantPipelineLayout: VkPipelineLayout, pushconstantShaderStageFlags: VkShaderStageFlags, pushconstantOffset: uint32, pushconstantSize: uint32, indirectStateFlags: VkIndirectStateFlagsNV, indexTypeCount: uint32, pIndexTypes: ptr VkIndexType, pIndexTypeValues: ptr uint32): VkIndirectCommandsLayoutTokenNV =
  result.sType = sType
  result.pNext = pNext
  result.tokenType = tokenType
  result.stream = stream
  result.offset = offset
  result.vertexBindingUnit = vertexBindingUnit
  result.vertexDynamicStride = vertexDynamicStride
  result.pushconstantPipelineLayout = pushconstantPipelineLayout
  result.pushconstantShaderStageFlags = pushconstantShaderStageFlags
  result.pushconstantOffset = pushconstantOffset
  result.pushconstantSize = pushconstantSize
  result.indirectStateFlags = indirectStateFlags
  result.indexTypeCount = indexTypeCount
  result.pIndexTypes = pIndexTypes
  result.pIndexTypeValues = pIndexTypeValues

proc newVkIndirectCommandsLayoutCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, flags: VkIndirectCommandsLayoutUsageFlagsNV = 0.VkIndirectCommandsLayoutUsageFlagsNV, pipelineBindPoint: VkPipelineBindPoint, tokenCount: uint32, pTokens: ptr VkIndirectCommandsLayoutTokenNV, streamCount: uint32, pStreamStrides: ptr uint32): VkIndirectCommandsLayoutCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.pipelineBindPoint = pipelineBindPoint
  result.tokenCount = tokenCount
  result.pTokens = pTokens
  result.streamCount = streamCount
  result.pStreamStrides = pStreamStrides

proc newVkGeneratedCommandsInfoNV*(sType: VkStructureType, pNext: pointer = nil, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, indirectCommandsLayout: VkIndirectCommandsLayoutNV, streamCount: uint32, pStreams: ptr VkIndirectCommandsStreamNV, sequencesCount: uint32, preprocessBuffer: VkBuffer, preprocessOffset: VkDeviceSize, preprocessSize: VkDeviceSize, sequencesCountBuffer: VkBuffer, sequencesCountOffset: VkDeviceSize, sequencesIndexBuffer: VkBuffer, sequencesIndexOffset: VkDeviceSize): VkGeneratedCommandsInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.pipelineBindPoint = pipelineBindPoint
  result.pipeline = pipeline
  result.indirectCommandsLayout = indirectCommandsLayout
  result.streamCount = streamCount
  result.pStreams = pStreams
  result.sequencesCount = sequencesCount
  result.preprocessBuffer = preprocessBuffer
  result.preprocessOffset = preprocessOffset
  result.preprocessSize = preprocessSize
  result.sequencesCountBuffer = sequencesCountBuffer
  result.sequencesCountOffset = sequencesCountOffset
  result.sequencesIndexBuffer = sequencesIndexBuffer
  result.sequencesIndexOffset = sequencesIndexOffset

proc newVkGeneratedCommandsMemoryRequirementsInfoNV*(sType: VkStructureType, pNext: pointer = nil, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, indirectCommandsLayout: VkIndirectCommandsLayoutNV, maxSequencesCount: uint32): VkGeneratedCommandsMemoryRequirementsInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.pipelineBindPoint = pipelineBindPoint
  result.pipeline = pipeline
  result.indirectCommandsLayout = indirectCommandsLayout
  result.maxSequencesCount = maxSequencesCount

proc newVkPhysicalDeviceFeatures2*(sType: VkStructureType, pNext: pointer = nil, features: VkPhysicalDeviceFeatures): VkPhysicalDeviceFeatures2 =
  result.sType = sType
  result.pNext = pNext
  result.features = features

proc newVkPhysicalDeviceProperties2*(sType: VkStructureType, pNext: pointer = nil, properties: VkPhysicalDeviceProperties): VkPhysicalDeviceProperties2 =
  result.sType = sType
  result.pNext = pNext
  result.properties = properties

proc newVkFormatProperties2*(sType: VkStructureType, pNext: pointer = nil, formatProperties: VkFormatProperties): VkFormatProperties2 =
  result.sType = sType
  result.pNext = pNext
  result.formatProperties = formatProperties

proc newVkImageFormatProperties2*(sType: VkStructureType, pNext: pointer = nil, imageFormatProperties: VkImageFormatProperties): VkImageFormatProperties2 =
  result.sType = sType
  result.pNext = pNext
  result.imageFormatProperties = imageFormatProperties

proc newVkPhysicalDeviceImageFormatInfo2*(sType: VkStructureType, pNext: pointer = nil, format: VkFormat, `type`: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags = 0.VkImageCreateFlags): VkPhysicalDeviceImageFormatInfo2 =
  result.sType = sType
  result.pNext = pNext
  result.format = format
  result.`type` = `type`
  result.tiling = tiling
  result.usage = usage
  result.flags = flags

proc newVkQueueFamilyProperties2*(sType: VkStructureType, pNext: pointer = nil, queueFamilyProperties: VkQueueFamilyProperties): VkQueueFamilyProperties2 =
  result.sType = sType
  result.pNext = pNext
  result.queueFamilyProperties = queueFamilyProperties

proc newVkPhysicalDeviceMemoryProperties2*(sType: VkStructureType, pNext: pointer = nil, memoryProperties: VkPhysicalDeviceMemoryProperties): VkPhysicalDeviceMemoryProperties2 =
  result.sType = sType
  result.pNext = pNext
  result.memoryProperties = memoryProperties

proc newVkSparseImageFormatProperties2*(sType: VkStructureType, pNext: pointer = nil, properties: VkSparseImageFormatProperties): VkSparseImageFormatProperties2 =
  result.sType = sType
  result.pNext = pNext
  result.properties = properties

proc newVkPhysicalDeviceSparseImageFormatInfo2*(sType: VkStructureType, pNext: pointer = nil, format: VkFormat, `type`: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling): VkPhysicalDeviceSparseImageFormatInfo2 =
  result.sType = sType
  result.pNext = pNext
  result.format = format
  result.`type` = `type`
  result.samples = samples
  result.usage = usage
  result.tiling = tiling

proc newVkPhysicalDevicePushDescriptorPropertiesKHR*(sType: VkStructureType, pNext: pointer = nil, maxPushDescriptors: uint32): VkPhysicalDevicePushDescriptorPropertiesKHR =
  result.sType = sType
  result.pNext = pNext
  result.maxPushDescriptors = maxPushDescriptors

proc newVkConformanceVersion*(major: uint8, minor: uint8, subminor: uint8, patch: uint8): VkConformanceVersion =
  result.major = major
  result.minor = minor
  result.subminor = subminor
  result.patch = patch

proc newVkPhysicalDeviceDriverProperties*(sType: VkStructureType, pNext: pointer = nil, driverID: VkDriverId, driverName: array[VK_MAX_DRIVER_NAME_SIZE, char], driverInfo: array[VK_MAX_DRIVER_INFO_SIZE, char], conformanceVersion: VkConformanceVersion): VkPhysicalDeviceDriverProperties =
  result.sType = sType
  result.pNext = pNext
  result.driverID = driverID
  result.driverName = driverName
  result.driverInfo = driverInfo
  result.conformanceVersion = conformanceVersion

proc newVkPresentRegionsKHR*(sType: VkStructureType, pNext: pointer = nil, swapchainCount: uint32, pRegions: ptr VkPresentRegionKHR): VkPresentRegionsKHR =
  result.sType = sType
  result.pNext = pNext
  result.swapchainCount = swapchainCount
  result.pRegions = pRegions

proc newVkPresentRegionKHR*(rectangleCount: uint32, pRectangles: ptr VkRectLayerKHR): VkPresentRegionKHR =
  result.rectangleCount = rectangleCount
  result.pRectangles = pRectangles

proc newVkRectLayerKHR*(offset: VkOffset2D, extent: VkExtent2D, layer: uint32): VkRectLayerKHR =
  result.offset = offset
  result.extent = extent
  result.layer = layer

proc newVkPhysicalDeviceVariablePointersFeatures*(sType: VkStructureType, pNext: pointer = nil, variablePointersStorageBuffer: VkBool32, variablePointers: VkBool32): VkPhysicalDeviceVariablePointersFeatures =
  result.sType = sType
  result.pNext = pNext
  result.variablePointersStorageBuffer = variablePointersStorageBuffer
  result.variablePointers = variablePointers

proc newVkExternalMemoryProperties*(externalMemoryFeatures: VkExternalMemoryFeatureFlags, exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlags, compatibleHandleTypes: VkExternalMemoryHandleTypeFlags): VkExternalMemoryProperties =
  result.externalMemoryFeatures = externalMemoryFeatures
  result.exportFromImportedHandleTypes = exportFromImportedHandleTypes
  result.compatibleHandleTypes = compatibleHandleTypes

proc newVkPhysicalDeviceExternalImageFormatInfo*(sType: VkStructureType, pNext: pointer = nil, handleType: VkExternalMemoryHandleTypeFlagBits): VkPhysicalDeviceExternalImageFormatInfo =
  result.sType = sType
  result.pNext = pNext
  result.handleType = handleType

proc newVkExternalImageFormatProperties*(sType: VkStructureType, pNext: pointer = nil, externalMemoryProperties: VkExternalMemoryProperties): VkExternalImageFormatProperties =
  result.sType = sType
  result.pNext = pNext
  result.externalMemoryProperties = externalMemoryProperties

proc newVkPhysicalDeviceExternalBufferInfo*(sType: VkStructureType, pNext: pointer = nil, flags: VkBufferCreateFlags = 0.VkBufferCreateFlags, usage: VkBufferUsageFlags, handleType: VkExternalMemoryHandleTypeFlagBits): VkPhysicalDeviceExternalBufferInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.usage = usage
  result.handleType = handleType

proc newVkExternalBufferProperties*(sType: VkStructureType, pNext: pointer = nil, externalMemoryProperties: VkExternalMemoryProperties): VkExternalBufferProperties =
  result.sType = sType
  result.pNext = pNext
  result.externalMemoryProperties = externalMemoryProperties

proc newVkPhysicalDeviceIDProperties*(sType: VkStructureType, pNext: pointer = nil, deviceUUID: array[VK_UUID_SIZE, uint8], driverUUID: array[VK_UUID_SIZE, uint8], deviceLUID: array[VK_LUID_SIZE, uint8], deviceNodeMask: uint32, deviceLUIDValid: VkBool32): VkPhysicalDeviceIDProperties =
  result.sType = sType
  result.pNext = pNext
  result.deviceUUID = deviceUUID
  result.driverUUID = driverUUID
  result.deviceLUID = deviceLUID
  result.deviceNodeMask = deviceNodeMask
  result.deviceLUIDValid = deviceLUIDValid

proc newVkExternalMemoryImageCreateInfo*(sType: VkStructureType, pNext: pointer = nil, handleTypes: VkExternalMemoryHandleTypeFlags): VkExternalMemoryImageCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.handleTypes = handleTypes

proc newVkExternalMemoryBufferCreateInfo*(sType: VkStructureType, pNext: pointer = nil, handleTypes: VkExternalMemoryHandleTypeFlags): VkExternalMemoryBufferCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.handleTypes = handleTypes

proc newVkExportMemoryAllocateInfo*(sType: VkStructureType, pNext: pointer = nil, handleTypes: VkExternalMemoryHandleTypeFlags): VkExportMemoryAllocateInfo =
  result.sType = sType
  result.pNext = pNext
  result.handleTypes = handleTypes

proc newVkImportMemoryWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, handleType: VkExternalMemoryHandleTypeFlagBits, handle: HANDLE, name: LPCWSTR): VkImportMemoryWin32HandleInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.handleType = handleType
  result.handle = handle
  result.name = name

proc newVkExportMemoryWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, pAttributes: ptr SECURITY_ATTRIBUTES, dwAccess: DWORD, name: LPCWSTR): VkExportMemoryWin32HandleInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.pAttributes = pAttributes
  result.dwAccess = dwAccess
  result.name = name

proc newVkMemoryWin32HandlePropertiesKHR*(sType: VkStructureType, pNext: pointer = nil, memoryTypeBits: uint32): VkMemoryWin32HandlePropertiesKHR =
  result.sType = sType
  result.pNext = pNext
  result.memoryTypeBits = memoryTypeBits

proc newVkMemoryGetWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, memory: VkDeviceMemory, handleType: VkExternalMemoryHandleTypeFlagBits): VkMemoryGetWin32HandleInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.memory = memory
  result.handleType = handleType

proc newVkImportMemoryFdInfoKHR*(sType: VkStructureType, pNext: pointer = nil, handleType: VkExternalMemoryHandleTypeFlagBits, fd: int): VkImportMemoryFdInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.handleType = handleType
  result.fd = fd

proc newVkMemoryFdPropertiesKHR*(sType: VkStructureType, pNext: pointer = nil, memoryTypeBits: uint32): VkMemoryFdPropertiesKHR =
  result.sType = sType
  result.pNext = pNext
  result.memoryTypeBits = memoryTypeBits

proc newVkMemoryGetFdInfoKHR*(sType: VkStructureType, pNext: pointer = nil, memory: VkDeviceMemory, handleType: VkExternalMemoryHandleTypeFlagBits): VkMemoryGetFdInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.memory = memory
  result.handleType = handleType

proc newVkWin32KeyedMutexAcquireReleaseInfoKHR*(sType: VkStructureType, pNext: pointer = nil, acquireCount: uint32, pAcquireSyncs: ptr VkDeviceMemory, pAcquireKeys: ptr uint64, pAcquireTimeouts: ptr uint32, releaseCount: uint32, pReleaseSyncs: ptr VkDeviceMemory, pReleaseKeys: ptr uint64): VkWin32KeyedMutexAcquireReleaseInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.acquireCount = acquireCount
  result.pAcquireSyncs = pAcquireSyncs
  result.pAcquireKeys = pAcquireKeys
  result.pAcquireTimeouts = pAcquireTimeouts
  result.releaseCount = releaseCount
  result.pReleaseSyncs = pReleaseSyncs
  result.pReleaseKeys = pReleaseKeys

proc newVkPhysicalDeviceExternalSemaphoreInfo*(sType: VkStructureType, pNext: pointer = nil, handleType: VkExternalSemaphoreHandleTypeFlagBits): VkPhysicalDeviceExternalSemaphoreInfo =
  result.sType = sType
  result.pNext = pNext
  result.handleType = handleType

proc newVkExternalSemaphoreProperties*(sType: VkStructureType, pNext: pointer = nil, exportFromImportedHandleTypes: VkExternalSemaphoreHandleTypeFlags, compatibleHandleTypes: VkExternalSemaphoreHandleTypeFlags, externalSemaphoreFeatures: VkExternalSemaphoreFeatureFlags): VkExternalSemaphoreProperties =
  result.sType = sType
  result.pNext = pNext
  result.exportFromImportedHandleTypes = exportFromImportedHandleTypes
  result.compatibleHandleTypes = compatibleHandleTypes
  result.externalSemaphoreFeatures = externalSemaphoreFeatures

proc newVkExportSemaphoreCreateInfo*(sType: VkStructureType, pNext: pointer = nil, handleTypes: VkExternalSemaphoreHandleTypeFlags): VkExportSemaphoreCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.handleTypes = handleTypes

proc newVkImportSemaphoreWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, semaphore: VkSemaphore, flags: VkSemaphoreImportFlags = 0.VkSemaphoreImportFlags, handleType: VkExternalSemaphoreHandleTypeFlagBits, handle: HANDLE, name: LPCWSTR): VkImportSemaphoreWin32HandleInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.semaphore = semaphore
  result.flags = flags
  result.handleType = handleType
  result.handle = handle
  result.name = name

proc newVkExportSemaphoreWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, pAttributes: ptr SECURITY_ATTRIBUTES, dwAccess: DWORD, name: LPCWSTR): VkExportSemaphoreWin32HandleInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.pAttributes = pAttributes
  result.dwAccess = dwAccess
  result.name = name

proc newVkD3D12FenceSubmitInfoKHR*(sType: VkStructureType, pNext: pointer = nil, waitSemaphoreValuesCount: uint32, pWaitSemaphoreValues: ptr uint64, signalSemaphoreValuesCount: uint32, pSignalSemaphoreValues: ptr uint64): VkD3D12FenceSubmitInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.waitSemaphoreValuesCount = waitSemaphoreValuesCount
  result.pWaitSemaphoreValues = pWaitSemaphoreValues
  result.signalSemaphoreValuesCount = signalSemaphoreValuesCount
  result.pSignalSemaphoreValues = pSignalSemaphoreValues

proc newVkSemaphoreGetWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, semaphore: VkSemaphore, handleType: VkExternalSemaphoreHandleTypeFlagBits): VkSemaphoreGetWin32HandleInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.semaphore = semaphore
  result.handleType = handleType

proc newVkImportSemaphoreFdInfoKHR*(sType: VkStructureType, pNext: pointer = nil, semaphore: VkSemaphore, flags: VkSemaphoreImportFlags = 0.VkSemaphoreImportFlags, handleType: VkExternalSemaphoreHandleTypeFlagBits, fd: int): VkImportSemaphoreFdInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.semaphore = semaphore
  result.flags = flags
  result.handleType = handleType
  result.fd = fd

proc newVkSemaphoreGetFdInfoKHR*(sType: VkStructureType, pNext: pointer = nil, semaphore: VkSemaphore, handleType: VkExternalSemaphoreHandleTypeFlagBits): VkSemaphoreGetFdInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.semaphore = semaphore
  result.handleType = handleType

proc newVkPhysicalDeviceExternalFenceInfo*(sType: VkStructureType, pNext: pointer = nil, handleType: VkExternalFenceHandleTypeFlagBits): VkPhysicalDeviceExternalFenceInfo =
  result.sType = sType
  result.pNext = pNext
  result.handleType = handleType

proc newVkExternalFenceProperties*(sType: VkStructureType, pNext: pointer = nil, exportFromImportedHandleTypes: VkExternalFenceHandleTypeFlags, compatibleHandleTypes: VkExternalFenceHandleTypeFlags, externalFenceFeatures: VkExternalFenceFeatureFlags): VkExternalFenceProperties =
  result.sType = sType
  result.pNext = pNext
  result.exportFromImportedHandleTypes = exportFromImportedHandleTypes
  result.compatibleHandleTypes = compatibleHandleTypes
  result.externalFenceFeatures = externalFenceFeatures

proc newVkExportFenceCreateInfo*(sType: VkStructureType, pNext: pointer = nil, handleTypes: VkExternalFenceHandleTypeFlags): VkExportFenceCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.handleTypes = handleTypes

proc newVkImportFenceWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, fence: VkFence, flags: VkFenceImportFlags = 0.VkFenceImportFlags, handleType: VkExternalFenceHandleTypeFlagBits, handle: HANDLE, name: LPCWSTR): VkImportFenceWin32HandleInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.fence = fence
  result.flags = flags
  result.handleType = handleType
  result.handle = handle
  result.name = name

proc newVkExportFenceWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, pAttributes: ptr SECURITY_ATTRIBUTES, dwAccess: DWORD, name: LPCWSTR): VkExportFenceWin32HandleInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.pAttributes = pAttributes
  result.dwAccess = dwAccess
  result.name = name

proc newVkFenceGetWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, fence: VkFence, handleType: VkExternalFenceHandleTypeFlagBits): VkFenceGetWin32HandleInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.fence = fence
  result.handleType = handleType

proc newVkImportFenceFdInfoKHR*(sType: VkStructureType, pNext: pointer = nil, fence: VkFence, flags: VkFenceImportFlags = 0.VkFenceImportFlags, handleType: VkExternalFenceHandleTypeFlagBits, fd: int): VkImportFenceFdInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.fence = fence
  result.flags = flags
  result.handleType = handleType
  result.fd = fd

proc newVkFenceGetFdInfoKHR*(sType: VkStructureType, pNext: pointer = nil, fence: VkFence, handleType: VkExternalFenceHandleTypeFlagBits): VkFenceGetFdInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.fence = fence
  result.handleType = handleType

proc newVkPhysicalDeviceMultiviewFeatures*(sType: VkStructureType, pNext: pointer = nil, multiview: VkBool32, multiviewGeometryShader: VkBool32, multiviewTessellationShader: VkBool32): VkPhysicalDeviceMultiviewFeatures =
  result.sType = sType
  result.pNext = pNext
  result.multiview = multiview
  result.multiviewGeometryShader = multiviewGeometryShader
  result.multiviewTessellationShader = multiviewTessellationShader

proc newVkPhysicalDeviceMultiviewProperties*(sType: VkStructureType, pNext: pointer = nil, maxMultiviewViewCount: uint32, maxMultiviewInstanceIndex: uint32): VkPhysicalDeviceMultiviewProperties =
  result.sType = sType
  result.pNext = pNext
  result.maxMultiviewViewCount = maxMultiviewViewCount
  result.maxMultiviewInstanceIndex = maxMultiviewInstanceIndex

proc newVkRenderPassMultiviewCreateInfo*(sType: VkStructureType, pNext: pointer = nil, subpassCount: uint32, pViewMasks: ptr uint32, dependencyCount: uint32, pViewOffsets: ptr int32, correlationMaskCount: uint32, pCorrelationMasks: ptr uint32): VkRenderPassMultiviewCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.subpassCount = subpassCount
  result.pViewMasks = pViewMasks
  result.dependencyCount = dependencyCount
  result.pViewOffsets = pViewOffsets
  result.correlationMaskCount = correlationMaskCount
  result.pCorrelationMasks = pCorrelationMasks

proc newVkSurfaceCapabilities2EXT*(sType: VkStructureType, pNext: pointer = nil, minImageCount: uint32, maxImageCount: uint32, currentExtent: VkExtent2D, minImageExtent: VkExtent2D, maxImageExtent: VkExtent2D, maxImageArrayLayers: uint32, supportedTransforms: VkSurfaceTransformFlagsKHR, currentTransform: VkSurfaceTransformFlagBitsKHR, supportedCompositeAlpha: VkCompositeAlphaFlagsKHR, supportedUsageFlags: VkImageUsageFlags, supportedSurfaceCounters: VkSurfaceCounterFlagsEXT): VkSurfaceCapabilities2EXT =
  result.sType = sType
  result.pNext = pNext
  result.minImageCount = minImageCount
  result.maxImageCount = maxImageCount
  result.currentExtent = currentExtent
  result.minImageExtent = minImageExtent
  result.maxImageExtent = maxImageExtent
  result.maxImageArrayLayers = maxImageArrayLayers
  result.supportedTransforms = supportedTransforms
  result.currentTransform = currentTransform
  result.supportedCompositeAlpha = supportedCompositeAlpha
  result.supportedUsageFlags = supportedUsageFlags
  result.supportedSurfaceCounters = supportedSurfaceCounters

proc newVkDisplayPowerInfoEXT*(sType: VkStructureType, pNext: pointer = nil, powerState: VkDisplayPowerStateEXT): VkDisplayPowerInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.powerState = powerState

proc newVkDeviceEventInfoEXT*(sType: VkStructureType, pNext: pointer = nil, deviceEvent: VkDeviceEventTypeEXT): VkDeviceEventInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.deviceEvent = deviceEvent

proc newVkDisplayEventInfoEXT*(sType: VkStructureType, pNext: pointer = nil, displayEvent: VkDisplayEventTypeEXT): VkDisplayEventInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.displayEvent = displayEvent

proc newVkSwapchainCounterCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, surfaceCounters: VkSurfaceCounterFlagsEXT): VkSwapchainCounterCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.surfaceCounters = surfaceCounters

proc newVkPhysicalDeviceGroupProperties*(sType: VkStructureType, pNext: pointer = nil, physicalDeviceCount: uint32, physicalDevices: array[VK_MAX_DEVICE_GROUP_SIZE, VkPhysicalDevice], subsetAllocation: VkBool32): VkPhysicalDeviceGroupProperties =
  result.sType = sType
  result.pNext = pNext
  result.physicalDeviceCount = physicalDeviceCount
  result.physicalDevices = physicalDevices
  result.subsetAllocation = subsetAllocation

proc newVkMemoryAllocateFlagsInfo*(sType: VkStructureType, pNext: pointer = nil, flags: VkMemoryAllocateFlags = 0.VkMemoryAllocateFlags, deviceMask: uint32): VkMemoryAllocateFlagsInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.deviceMask = deviceMask

proc newVkBindBufferMemoryInfo*(sType: VkStructureType, pNext: pointer = nil, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkBindBufferMemoryInfo =
  result.sType = sType
  result.pNext = pNext
  result.buffer = buffer
  result.memory = memory
  result.memoryOffset = memoryOffset

proc newVkBindBufferMemoryDeviceGroupInfo*(sType: VkStructureType, pNext: pointer = nil, deviceIndexCount: uint32, pDeviceIndices: ptr uint32): VkBindBufferMemoryDeviceGroupInfo =
  result.sType = sType
  result.pNext = pNext
  result.deviceIndexCount = deviceIndexCount
  result.pDeviceIndices = pDeviceIndices

proc newVkBindImageMemoryInfo*(sType: VkStructureType, pNext: pointer = nil, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkBindImageMemoryInfo =
  result.sType = sType
  result.pNext = pNext
  result.image = image
  result.memory = memory
  result.memoryOffset = memoryOffset

proc newVkBindImageMemoryDeviceGroupInfo*(sType: VkStructureType, pNext: pointer = nil, deviceIndexCount: uint32, pDeviceIndices: ptr uint32, splitInstanceBindRegionCount: uint32, pSplitInstanceBindRegions: ptr VkRect2D): VkBindImageMemoryDeviceGroupInfo =
  result.sType = sType
  result.pNext = pNext
  result.deviceIndexCount = deviceIndexCount
  result.pDeviceIndices = pDeviceIndices
  result.splitInstanceBindRegionCount = splitInstanceBindRegionCount
  result.pSplitInstanceBindRegions = pSplitInstanceBindRegions

proc newVkDeviceGroupRenderPassBeginInfo*(sType: VkStructureType, pNext: pointer = nil, deviceMask: uint32, deviceRenderAreaCount: uint32, pDeviceRenderAreas: ptr VkRect2D): VkDeviceGroupRenderPassBeginInfo =
  result.sType = sType
  result.pNext = pNext
  result.deviceMask = deviceMask
  result.deviceRenderAreaCount = deviceRenderAreaCount
  result.pDeviceRenderAreas = pDeviceRenderAreas

proc newVkDeviceGroupCommandBufferBeginInfo*(sType: VkStructureType, pNext: pointer = nil, deviceMask: uint32): VkDeviceGroupCommandBufferBeginInfo =
  result.sType = sType
  result.pNext = pNext
  result.deviceMask = deviceMask

proc newVkDeviceGroupSubmitInfo*(sType: VkStructureType, pNext: pointer = nil, waitSemaphoreCount: uint32, pWaitSemaphoreDeviceIndices: ptr uint32, commandBufferCount: uint32, pCommandBufferDeviceMasks: ptr uint32, signalSemaphoreCount: uint32, pSignalSemaphoreDeviceIndices: ptr uint32): VkDeviceGroupSubmitInfo =
  result.sType = sType
  result.pNext = pNext
  result.waitSemaphoreCount = waitSemaphoreCount
  result.pWaitSemaphoreDeviceIndices = pWaitSemaphoreDeviceIndices
  result.commandBufferCount = commandBufferCount
  result.pCommandBufferDeviceMasks = pCommandBufferDeviceMasks
  result.signalSemaphoreCount = signalSemaphoreCount
  result.pSignalSemaphoreDeviceIndices = pSignalSemaphoreDeviceIndices

proc newVkDeviceGroupBindSparseInfo*(sType: VkStructureType, pNext: pointer = nil, resourceDeviceIndex: uint32, memoryDeviceIndex: uint32): VkDeviceGroupBindSparseInfo =
  result.sType = sType
  result.pNext = pNext
  result.resourceDeviceIndex = resourceDeviceIndex
  result.memoryDeviceIndex = memoryDeviceIndex

proc newVkDeviceGroupPresentCapabilitiesKHR*(sType: VkStructureType, pNext: pointer = nil, presentMask: array[VK_MAX_DEVICE_GROUP_SIZE, uint32], modes: VkDeviceGroupPresentModeFlagsKHR): VkDeviceGroupPresentCapabilitiesKHR =
  result.sType = sType
  result.pNext = pNext
  result.presentMask = presentMask
  result.modes = modes

proc newVkImageSwapchainCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, swapchain: VkSwapchainKHR): VkImageSwapchainCreateInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.swapchain = swapchain

proc newVkBindImageMemorySwapchainInfoKHR*(sType: VkStructureType, pNext: pointer = nil, swapchain: VkSwapchainKHR, imageIndex: uint32): VkBindImageMemorySwapchainInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.swapchain = swapchain
  result.imageIndex = imageIndex

proc newVkAcquireNextImageInfoKHR*(sType: VkStructureType, pNext: pointer = nil, swapchain: VkSwapchainKHR, timeout: uint64, semaphore: VkSemaphore, fence: VkFence, deviceMask: uint32): VkAcquireNextImageInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.swapchain = swapchain
  result.timeout = timeout
  result.semaphore = semaphore
  result.fence = fence
  result.deviceMask = deviceMask

proc newVkDeviceGroupPresentInfoKHR*(sType: VkStructureType, pNext: pointer = nil, swapchainCount: uint32, pDeviceMasks: ptr uint32, mode: VkDeviceGroupPresentModeFlagBitsKHR): VkDeviceGroupPresentInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.swapchainCount = swapchainCount
  result.pDeviceMasks = pDeviceMasks
  result.mode = mode

proc newVkDeviceGroupDeviceCreateInfo*(sType: VkStructureType, pNext: pointer = nil, physicalDeviceCount: uint32, pPhysicalDevices: ptr VkPhysicalDevice): VkDeviceGroupDeviceCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.physicalDeviceCount = physicalDeviceCount
  result.pPhysicalDevices = pPhysicalDevices

proc newVkDeviceGroupSwapchainCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, modes: VkDeviceGroupPresentModeFlagsKHR): VkDeviceGroupSwapchainCreateInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.modes = modes

proc newVkDescriptorUpdateTemplateEntry*(dstBinding: uint32, dstArrayElement: uint32, descriptorCount: uint32, descriptorType: VkDescriptorType, offset: uint, stride: uint): VkDescriptorUpdateTemplateEntry =
  result.dstBinding = dstBinding
  result.dstArrayElement = dstArrayElement
  result.descriptorCount = descriptorCount
  result.descriptorType = descriptorType
  result.offset = offset
  result.stride = stride

proc newVkDescriptorUpdateTemplateCreateInfo*(sType: VkStructureType, pNext: pointer = nil, flags: VkDescriptorUpdateTemplateCreateFlags = 0.VkDescriptorUpdateTemplateCreateFlags, descriptorUpdateEntryCount: uint32, pDescriptorUpdateEntries: ptr VkDescriptorUpdateTemplateEntry, templateType: VkDescriptorUpdateTemplateType, descriptorSetLayout: VkDescriptorSetLayout, pipelineBindPoint: VkPipelineBindPoint, pipelineLayout: VkPipelineLayout, set: uint32): VkDescriptorUpdateTemplateCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.descriptorUpdateEntryCount = descriptorUpdateEntryCount
  result.pDescriptorUpdateEntries = pDescriptorUpdateEntries
  result.templateType = templateType
  result.descriptorSetLayout = descriptorSetLayout
  result.pipelineBindPoint = pipelineBindPoint
  result.pipelineLayout = pipelineLayout
  result.set = set

proc newVkXYColorEXT*(x: float32, y: float32): VkXYColorEXT =
  result.x = x
  result.y = y

proc newVkHdrMetadataEXT*(sType: VkStructureType, pNext: pointer = nil, displayPrimaryRed: VkXYColorEXT, displayPrimaryGreen: VkXYColorEXT, displayPrimaryBlue: VkXYColorEXT, whitePoint: VkXYColorEXT, maxLuminance: float32, minLuminance: float32, maxContentLightLevel: float32, maxFrameAverageLightLevel: float32): VkHdrMetadataEXT =
  result.sType = sType
  result.pNext = pNext
  result.displayPrimaryRed = displayPrimaryRed
  result.displayPrimaryGreen = displayPrimaryGreen
  result.displayPrimaryBlue = displayPrimaryBlue
  result.whitePoint = whitePoint
  result.maxLuminance = maxLuminance
  result.minLuminance = minLuminance
  result.maxContentLightLevel = maxContentLightLevel
  result.maxFrameAverageLightLevel = maxFrameAverageLightLevel

proc newVkDisplayNativeHdrSurfaceCapabilitiesAMD*(sType: VkStructureType, pNext: pointer = nil, localDimmingSupport: VkBool32): VkDisplayNativeHdrSurfaceCapabilitiesAMD =
  result.sType = sType
  result.pNext = pNext
  result.localDimmingSupport = localDimmingSupport

proc newVkSwapchainDisplayNativeHdrCreateInfoAMD*(sType: VkStructureType, pNext: pointer = nil, localDimmingEnable: VkBool32): VkSwapchainDisplayNativeHdrCreateInfoAMD =
  result.sType = sType
  result.pNext = pNext
  result.localDimmingEnable = localDimmingEnable

proc newVkRefreshCycleDurationGOOGLE*(refreshDuration: uint64): VkRefreshCycleDurationGOOGLE =
  result.refreshDuration = refreshDuration

proc newVkPastPresentationTimingGOOGLE*(presentID: uint32, desiredPresentTime: uint64, actualPresentTime: uint64, earliestPresentTime: uint64, presentMargin: uint64): VkPastPresentationTimingGOOGLE =
  result.presentID = presentID
  result.desiredPresentTime = desiredPresentTime
  result.actualPresentTime = actualPresentTime
  result.earliestPresentTime = earliestPresentTime
  result.presentMargin = presentMargin

proc newVkPresentTimesInfoGOOGLE*(sType: VkStructureType, pNext: pointer = nil, swapchainCount: uint32, pTimes: ptr VkPresentTimeGOOGLE): VkPresentTimesInfoGOOGLE =
  result.sType = sType
  result.pNext = pNext
  result.swapchainCount = swapchainCount
  result.pTimes = pTimes

proc newVkPresentTimeGOOGLE*(presentID: uint32, desiredPresentTime: uint64): VkPresentTimeGOOGLE =
  result.presentID = presentID
  result.desiredPresentTime = desiredPresentTime

proc newVkIOSSurfaceCreateInfoMVK*(sType: VkStructureType, pNext: pointer = nil, flags: VkIOSSurfaceCreateFlagsMVK = 0.VkIOSSurfaceCreateFlagsMVK, pView: pointer = nil): VkIOSSurfaceCreateInfoMVK =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.pView = pView

proc newVkMacOSSurfaceCreateInfoMVK*(sType: VkStructureType, pNext: pointer = nil, flags: VkMacOSSurfaceCreateFlagsMVK = 0.VkMacOSSurfaceCreateFlagsMVK, pView: pointer = nil): VkMacOSSurfaceCreateInfoMVK =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.pView = pView

proc newVkMetalSurfaceCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkMetalSurfaceCreateFlagsEXT = 0.VkMetalSurfaceCreateFlagsEXT, pLayer: ptr CAMetalLayer): VkMetalSurfaceCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.pLayer = pLayer

proc newVkViewportWScalingNV*(xcoeff: float32, ycoeff: float32): VkViewportWScalingNV =
  result.xcoeff = xcoeff
  result.ycoeff = ycoeff

proc newVkPipelineViewportWScalingStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, viewportWScalingEnable: VkBool32, viewportCount: uint32, pViewportWScalings: ptr VkViewportWScalingNV): VkPipelineViewportWScalingStateCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.viewportWScalingEnable = viewportWScalingEnable
  result.viewportCount = viewportCount
  result.pViewportWScalings = pViewportWScalings

proc newVkViewportSwizzleNV*(x: VkViewportCoordinateSwizzleNV, y: VkViewportCoordinateSwizzleNV, z: VkViewportCoordinateSwizzleNV, w: VkViewportCoordinateSwizzleNV): VkViewportSwizzleNV =
  result.x = x
  result.y = y
  result.z = z
  result.w = w

proc newVkPipelineViewportSwizzleStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineViewportSwizzleStateCreateFlagsNV = 0.VkPipelineViewportSwizzleStateCreateFlagsNV, viewportCount: uint32, pViewportSwizzles: ptr VkViewportSwizzleNV): VkPipelineViewportSwizzleStateCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.viewportCount = viewportCount
  result.pViewportSwizzles = pViewportSwizzles

proc newVkPhysicalDeviceDiscardRectanglePropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, maxDiscardRectangles: uint32): VkPhysicalDeviceDiscardRectanglePropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.maxDiscardRectangles = maxDiscardRectangles

proc newVkPipelineDiscardRectangleStateCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineDiscardRectangleStateCreateFlagsEXT = 0.VkPipelineDiscardRectangleStateCreateFlagsEXT, discardRectangleMode: VkDiscardRectangleModeEXT, discardRectangleCount: uint32, pDiscardRectangles: ptr VkRect2D): VkPipelineDiscardRectangleStateCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.discardRectangleMode = discardRectangleMode
  result.discardRectangleCount = discardRectangleCount
  result.pDiscardRectangles = pDiscardRectangles

proc newVkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*(sType: VkStructureType, pNext: pointer = nil, perViewPositionAllComponents: VkBool32): VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX =
  result.sType = sType
  result.pNext = pNext
  result.perViewPositionAllComponents = perViewPositionAllComponents

proc newVkInputAttachmentAspectReference*(subpass: uint32, inputAttachmentIndex: uint32, aspectMask: VkImageAspectFlags): VkInputAttachmentAspectReference =
  result.subpass = subpass
  result.inputAttachmentIndex = inputAttachmentIndex
  result.aspectMask = aspectMask

proc newVkRenderPassInputAttachmentAspectCreateInfo*(sType: VkStructureType, pNext: pointer = nil, aspectReferenceCount: uint32, pAspectReferences: ptr VkInputAttachmentAspectReference): VkRenderPassInputAttachmentAspectCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.aspectReferenceCount = aspectReferenceCount
  result.pAspectReferences = pAspectReferences

proc newVkPhysicalDeviceSurfaceInfo2KHR*(sType: VkStructureType, pNext: pointer = nil, surface: VkSurfaceKHR): VkPhysicalDeviceSurfaceInfo2KHR =
  result.sType = sType
  result.pNext = pNext
  result.surface = surface

proc newVkSurfaceCapabilities2KHR*(sType: VkStructureType, pNext: pointer = nil, surfaceCapabilities: VkSurfaceCapabilitiesKHR): VkSurfaceCapabilities2KHR =
  result.sType = sType
  result.pNext = pNext
  result.surfaceCapabilities = surfaceCapabilities

proc newVkSurfaceFormat2KHR*(sType: VkStructureType, pNext: pointer = nil, surfaceFormat: VkSurfaceFormatKHR): VkSurfaceFormat2KHR =
  result.sType = sType
  result.pNext = pNext
  result.surfaceFormat = surfaceFormat

proc newVkDisplayProperties2KHR*(sType: VkStructureType, pNext: pointer = nil, displayProperties: VkDisplayPropertiesKHR): VkDisplayProperties2KHR =
  result.sType = sType
  result.pNext = pNext
  result.displayProperties = displayProperties

proc newVkDisplayPlaneProperties2KHR*(sType: VkStructureType, pNext: pointer = nil, displayPlaneProperties: VkDisplayPlanePropertiesKHR): VkDisplayPlaneProperties2KHR =
  result.sType = sType
  result.pNext = pNext
  result.displayPlaneProperties = displayPlaneProperties

proc newVkDisplayModeProperties2KHR*(sType: VkStructureType, pNext: pointer = nil, displayModeProperties: VkDisplayModePropertiesKHR): VkDisplayModeProperties2KHR =
  result.sType = sType
  result.pNext = pNext
  result.displayModeProperties = displayModeProperties

proc newVkDisplayPlaneInfo2KHR*(sType: VkStructureType, pNext: pointer = nil, mode: VkDisplayModeKHR, planeIndex: uint32): VkDisplayPlaneInfo2KHR =
  result.sType = sType
  result.pNext = pNext
  result.mode = mode
  result.planeIndex = planeIndex

proc newVkDisplayPlaneCapabilities2KHR*(sType: VkStructureType, pNext: pointer = nil, capabilities: VkDisplayPlaneCapabilitiesKHR): VkDisplayPlaneCapabilities2KHR =
  result.sType = sType
  result.pNext = pNext
  result.capabilities = capabilities

proc newVkSharedPresentSurfaceCapabilitiesKHR*(sType: VkStructureType, pNext: pointer = nil, sharedPresentSupportedUsageFlags: VkImageUsageFlags): VkSharedPresentSurfaceCapabilitiesKHR =
  result.sType = sType
  result.pNext = pNext
  result.sharedPresentSupportedUsageFlags = sharedPresentSupportedUsageFlags

proc newVkPhysicalDevice16BitStorageFeatures*(sType: VkStructureType, pNext: pointer = nil, storageBuffer16BitAccess: VkBool32, uniformAndStorageBuffer16BitAccess: VkBool32, storagePushConstant16: VkBool32, storageInputOutput16: VkBool32): VkPhysicalDevice16BitStorageFeatures =
  result.sType = sType
  result.pNext = pNext
  result.storageBuffer16BitAccess = storageBuffer16BitAccess
  result.uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess
  result.storagePushConstant16 = storagePushConstant16
  result.storageInputOutput16 = storageInputOutput16

proc newVkPhysicalDeviceSubgroupProperties*(sType: VkStructureType, pNext: pointer = nil, subgroupSize: uint32, supportedStages: VkShaderStageFlags, supportedOperations: VkSubgroupFeatureFlags, quadOperationsInAllStages: VkBool32): VkPhysicalDeviceSubgroupProperties =
  result.sType = sType
  result.pNext = pNext
  result.subgroupSize = subgroupSize
  result.supportedStages = supportedStages
  result.supportedOperations = supportedOperations
  result.quadOperationsInAllStages = quadOperationsInAllStages

proc newVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*(sType: VkStructureType, pNext: pointer = nil, shaderSubgroupExtendedTypes: VkBool32): VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures =
  result.sType = sType
  result.pNext = pNext
  result.shaderSubgroupExtendedTypes = shaderSubgroupExtendedTypes

proc newVkBufferMemoryRequirementsInfo2*(sType: VkStructureType, pNext: pointer = nil, buffer: VkBuffer): VkBufferMemoryRequirementsInfo2 =
  result.sType = sType
  result.pNext = pNext
  result.buffer = buffer

proc newVkImageMemoryRequirementsInfo2*(sType: VkStructureType, pNext: pointer = nil, image: VkImage): VkImageMemoryRequirementsInfo2 =
  result.sType = sType
  result.pNext = pNext
  result.image = image

proc newVkImageSparseMemoryRequirementsInfo2*(sType: VkStructureType, pNext: pointer = nil, image: VkImage): VkImageSparseMemoryRequirementsInfo2 =
  result.sType = sType
  result.pNext = pNext
  result.image = image

proc newVkMemoryRequirements2*(sType: VkStructureType, pNext: pointer = nil, memoryRequirements: VkMemoryRequirements): VkMemoryRequirements2 =
  result.sType = sType
  result.pNext = pNext
  result.memoryRequirements = memoryRequirements

proc newVkSparseImageMemoryRequirements2*(sType: VkStructureType, pNext: pointer = nil, memoryRequirements: VkSparseImageMemoryRequirements): VkSparseImageMemoryRequirements2 =
  result.sType = sType
  result.pNext = pNext
  result.memoryRequirements = memoryRequirements

proc newVkPhysicalDevicePointClippingProperties*(sType: VkStructureType, pNext: pointer = nil, pointClippingBehavior: VkPointClippingBehavior): VkPhysicalDevicePointClippingProperties =
  result.sType = sType
  result.pNext = pNext
  result.pointClippingBehavior = pointClippingBehavior

proc newVkMemoryDedicatedRequirements*(sType: VkStructureType, pNext: pointer = nil, prefersDedicatedAllocation: VkBool32, requiresDedicatedAllocation: VkBool32): VkMemoryDedicatedRequirements =
  result.sType = sType
  result.pNext = pNext
  result.prefersDedicatedAllocation = prefersDedicatedAllocation
  result.requiresDedicatedAllocation = requiresDedicatedAllocation

proc newVkMemoryDedicatedAllocateInfo*(sType: VkStructureType, pNext: pointer = nil, image: VkImage, buffer: VkBuffer): VkMemoryDedicatedAllocateInfo =
  result.sType = sType
  result.pNext = pNext
  result.image = image
  result.buffer = buffer

proc newVkImageViewUsageCreateInfo*(sType: VkStructureType, pNext: pointer = nil, usage: VkImageUsageFlags): VkImageViewUsageCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.usage = usage

proc newVkPipelineTessellationDomainOriginStateCreateInfo*(sType: VkStructureType, pNext: pointer = nil, domainOrigin: VkTessellationDomainOrigin): VkPipelineTessellationDomainOriginStateCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.domainOrigin = domainOrigin

proc newVkSamplerYcbcrConversionInfo*(sType: VkStructureType, pNext: pointer = nil, conversion: VkSamplerYcbcrConversion): VkSamplerYcbcrConversionInfo =
  result.sType = sType
  result.pNext = pNext
  result.conversion = conversion

proc newVkSamplerYcbcrConversionCreateInfo*(sType: VkStructureType, pNext: pointer = nil, format: VkFormat, ycbcrModel: VkSamplerYcbcrModelConversion, ycbcrRange: VkSamplerYcbcrRange, components: VkComponentMapping, xChromaOffset: VkChromaLocation, yChromaOffset: VkChromaLocation, chromaFilter: VkFilter, forceExplicitReconstruction: VkBool32): VkSamplerYcbcrConversionCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.format = format
  result.ycbcrModel = ycbcrModel
  result.ycbcrRange = ycbcrRange
  result.components = components
  result.xChromaOffset = xChromaOffset
  result.yChromaOffset = yChromaOffset
  result.chromaFilter = chromaFilter
  result.forceExplicitReconstruction = forceExplicitReconstruction

proc newVkBindImagePlaneMemoryInfo*(sType: VkStructureType, pNext: pointer = nil, planeAspect: VkImageAspectFlagBits): VkBindImagePlaneMemoryInfo =
  result.sType = sType
  result.pNext = pNext
  result.planeAspect = planeAspect

proc newVkImagePlaneMemoryRequirementsInfo*(sType: VkStructureType, pNext: pointer = nil, planeAspect: VkImageAspectFlagBits): VkImagePlaneMemoryRequirementsInfo =
  result.sType = sType
  result.pNext = pNext
  result.planeAspect = planeAspect

proc newVkPhysicalDeviceSamplerYcbcrConversionFeatures*(sType: VkStructureType, pNext: pointer = nil, samplerYcbcrConversion: VkBool32): VkPhysicalDeviceSamplerYcbcrConversionFeatures =
  result.sType = sType
  result.pNext = pNext
  result.samplerYcbcrConversion = samplerYcbcrConversion

proc newVkSamplerYcbcrConversionImageFormatProperties*(sType: VkStructureType, pNext: pointer = nil, combinedImageSamplerDescriptorCount: uint32): VkSamplerYcbcrConversionImageFormatProperties =
  result.sType = sType
  result.pNext = pNext
  result.combinedImageSamplerDescriptorCount = combinedImageSamplerDescriptorCount

proc newVkTextureLODGatherFormatPropertiesAMD*(sType: VkStructureType, pNext: pointer = nil, supportsTextureGatherLODBiasAMD: VkBool32): VkTextureLODGatherFormatPropertiesAMD =
  result.sType = sType
  result.pNext = pNext
  result.supportsTextureGatherLODBiasAMD = supportsTextureGatherLODBiasAMD

proc newVkConditionalRenderingBeginInfoEXT*(sType: VkStructureType, pNext: pointer = nil, buffer: VkBuffer, offset: VkDeviceSize, flags: VkConditionalRenderingFlagsEXT = 0.VkConditionalRenderingFlagsEXT): VkConditionalRenderingBeginInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.buffer = buffer
  result.offset = offset
  result.flags = flags

proc newVkProtectedSubmitInfo*(sType: VkStructureType, pNext: pointer = nil, protectedSubmit: VkBool32): VkProtectedSubmitInfo =
  result.sType = sType
  result.pNext = pNext
  result.protectedSubmit = protectedSubmit

proc newVkPhysicalDeviceProtectedMemoryFeatures*(sType: VkStructureType, pNext: pointer = nil, protectedMemory: VkBool32): VkPhysicalDeviceProtectedMemoryFeatures =
  result.sType = sType
  result.pNext = pNext
  result.protectedMemory = protectedMemory

proc newVkPhysicalDeviceProtectedMemoryProperties*(sType: VkStructureType, pNext: pointer = nil, protectedNoFault: VkBool32): VkPhysicalDeviceProtectedMemoryProperties =
  result.sType = sType
  result.pNext = pNext
  result.protectedNoFault = protectedNoFault

proc newVkDeviceQueueInfo2*(sType: VkStructureType, pNext: pointer = nil, flags: VkDeviceQueueCreateFlags = 0.VkDeviceQueueCreateFlags, queueFamilyIndex: uint32, queueIndex: uint32): VkDeviceQueueInfo2 =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.queueFamilyIndex = queueFamilyIndex
  result.queueIndex = queueIndex

proc newVkPipelineCoverageToColorStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineCoverageToColorStateCreateFlagsNV = 0.VkPipelineCoverageToColorStateCreateFlagsNV, coverageToColorEnable: VkBool32, coverageToColorLocation: uint32): VkPipelineCoverageToColorStateCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.coverageToColorEnable = coverageToColorEnable
  result.coverageToColorLocation = coverageToColorLocation

proc newVkPhysicalDeviceSamplerFilterMinmaxProperties*(sType: VkStructureType, pNext: pointer = nil, filterMinmaxSingleComponentFormats: VkBool32, filterMinmaxImageComponentMapping: VkBool32): VkPhysicalDeviceSamplerFilterMinmaxProperties =
  result.sType = sType
  result.pNext = pNext
  result.filterMinmaxSingleComponentFormats = filterMinmaxSingleComponentFormats
  result.filterMinmaxImageComponentMapping = filterMinmaxImageComponentMapping

proc newVkSampleLocationEXT*(x: float32, y: float32): VkSampleLocationEXT =
  result.x = x
  result.y = y

proc newVkSampleLocationsInfoEXT*(sType: VkStructureType, pNext: pointer = nil, sampleLocationsPerPixel: VkSampleCountFlagBits, sampleLocationGridSize: VkExtent2D, sampleLocationsCount: uint32, pSampleLocations: ptr VkSampleLocationEXT): VkSampleLocationsInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.sampleLocationsPerPixel = sampleLocationsPerPixel
  result.sampleLocationGridSize = sampleLocationGridSize
  result.sampleLocationsCount = sampleLocationsCount
  result.pSampleLocations = pSampleLocations

proc newVkAttachmentSampleLocationsEXT*(attachmentIndex: uint32, sampleLocationsInfo: VkSampleLocationsInfoEXT): VkAttachmentSampleLocationsEXT =
  result.attachmentIndex = attachmentIndex
  result.sampleLocationsInfo = sampleLocationsInfo

proc newVkSubpassSampleLocationsEXT*(subpassIndex: uint32, sampleLocationsInfo: VkSampleLocationsInfoEXT): VkSubpassSampleLocationsEXT =
  result.subpassIndex = subpassIndex
  result.sampleLocationsInfo = sampleLocationsInfo

proc newVkRenderPassSampleLocationsBeginInfoEXT*(sType: VkStructureType, pNext: pointer = nil, attachmentInitialSampleLocationsCount: uint32, pAttachmentInitialSampleLocations: ptr VkAttachmentSampleLocationsEXT, postSubpassSampleLocationsCount: uint32, pPostSubpassSampleLocations: ptr VkSubpassSampleLocationsEXT): VkRenderPassSampleLocationsBeginInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.attachmentInitialSampleLocationsCount = attachmentInitialSampleLocationsCount
  result.pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations
  result.postSubpassSampleLocationsCount = postSubpassSampleLocationsCount
  result.pPostSubpassSampleLocations = pPostSubpassSampleLocations

proc newVkPipelineSampleLocationsStateCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, sampleLocationsEnable: VkBool32, sampleLocationsInfo: VkSampleLocationsInfoEXT): VkPipelineSampleLocationsStateCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.sampleLocationsEnable = sampleLocationsEnable
  result.sampleLocationsInfo = sampleLocationsInfo

proc newVkPhysicalDeviceSampleLocationsPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, sampleLocationSampleCounts: VkSampleCountFlags, maxSampleLocationGridSize: VkExtent2D, sampleLocationCoordinateRange: array[2, float32], sampleLocationSubPixelBits: uint32, variableSampleLocations: VkBool32): VkPhysicalDeviceSampleLocationsPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.sampleLocationSampleCounts = sampleLocationSampleCounts
  result.maxSampleLocationGridSize = maxSampleLocationGridSize
  result.sampleLocationCoordinateRange = sampleLocationCoordinateRange
  result.sampleLocationSubPixelBits = sampleLocationSubPixelBits
  result.variableSampleLocations = variableSampleLocations

proc newVkMultisamplePropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, maxSampleLocationGridSize: VkExtent2D): VkMultisamplePropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.maxSampleLocationGridSize = maxSampleLocationGridSize

proc newVkSamplerReductionModeCreateInfo*(sType: VkStructureType, pNext: pointer = nil, reductionMode: VkSamplerReductionMode): VkSamplerReductionModeCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.reductionMode = reductionMode

proc newVkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, advancedBlendCoherentOperations: VkBool32): VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.advancedBlendCoherentOperations = advancedBlendCoherentOperations

proc newVkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, advancedBlendMaxColorAttachments: uint32, advancedBlendIndependentBlend: VkBool32, advancedBlendNonPremultipliedSrcColor: VkBool32, advancedBlendNonPremultipliedDstColor: VkBool32, advancedBlendCorrelatedOverlap: VkBool32, advancedBlendAllOperations: VkBool32): VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.advancedBlendMaxColorAttachments = advancedBlendMaxColorAttachments
  result.advancedBlendIndependentBlend = advancedBlendIndependentBlend
  result.advancedBlendNonPremultipliedSrcColor = advancedBlendNonPremultipliedSrcColor
  result.advancedBlendNonPremultipliedDstColor = advancedBlendNonPremultipliedDstColor
  result.advancedBlendCorrelatedOverlap = advancedBlendCorrelatedOverlap
  result.advancedBlendAllOperations = advancedBlendAllOperations

proc newVkPipelineColorBlendAdvancedStateCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, srcPremultiplied: VkBool32, dstPremultiplied: VkBool32, blendOverlap: VkBlendOverlapEXT): VkPipelineColorBlendAdvancedStateCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.srcPremultiplied = srcPremultiplied
  result.dstPremultiplied = dstPremultiplied
  result.blendOverlap = blendOverlap

proc newVkPhysicalDeviceInlineUniformBlockFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, inlineUniformBlock: VkBool32, descriptorBindingInlineUniformBlockUpdateAfterBind: VkBool32): VkPhysicalDeviceInlineUniformBlockFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.inlineUniformBlock = inlineUniformBlock
  result.descriptorBindingInlineUniformBlockUpdateAfterBind = descriptorBindingInlineUniformBlockUpdateAfterBind

proc newVkPhysicalDeviceInlineUniformBlockPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, maxInlineUniformBlockSize: uint32, maxPerStageDescriptorInlineUniformBlocks: uint32, maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: uint32, maxDescriptorSetInlineUniformBlocks: uint32, maxDescriptorSetUpdateAfterBindInlineUniformBlocks: uint32): VkPhysicalDeviceInlineUniformBlockPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.maxInlineUniformBlockSize = maxInlineUniformBlockSize
  result.maxPerStageDescriptorInlineUniformBlocks = maxPerStageDescriptorInlineUniformBlocks
  result.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks
  result.maxDescriptorSetInlineUniformBlocks = maxDescriptorSetInlineUniformBlocks
  result.maxDescriptorSetUpdateAfterBindInlineUniformBlocks = maxDescriptorSetUpdateAfterBindInlineUniformBlocks

proc newVkWriteDescriptorSetInlineUniformBlockEXT*(sType: VkStructureType, pNext: pointer = nil, dataSize: uint32, pData: pointer = nil): VkWriteDescriptorSetInlineUniformBlockEXT =
  result.sType = sType
  result.pNext = pNext
  result.dataSize = dataSize
  result.pData = pData

proc newVkDescriptorPoolInlineUniformBlockCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, maxInlineUniformBlockBindings: uint32): VkDescriptorPoolInlineUniformBlockCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.maxInlineUniformBlockBindings = maxInlineUniformBlockBindings

proc newVkPipelineCoverageModulationStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineCoverageModulationStateCreateFlagsNV = 0.VkPipelineCoverageModulationStateCreateFlagsNV, coverageModulationMode: VkCoverageModulationModeNV, coverageModulationTableEnable: VkBool32, coverageModulationTableCount: uint32, pCoverageModulationTable: ptr float32): VkPipelineCoverageModulationStateCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.coverageModulationMode = coverageModulationMode
  result.coverageModulationTableEnable = coverageModulationTableEnable
  result.coverageModulationTableCount = coverageModulationTableCount
  result.pCoverageModulationTable = pCoverageModulationTable

proc newVkImageFormatListCreateInfo*(sType: VkStructureType, pNext: pointer = nil, viewFormatCount: uint32, pViewFormats: ptr VkFormat): VkImageFormatListCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.viewFormatCount = viewFormatCount
  result.pViewFormats = pViewFormats

proc newVkValidationCacheCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkValidationCacheCreateFlagsEXT = 0.VkValidationCacheCreateFlagsEXT, initialDataSize: uint, pInitialData: pointer = nil): VkValidationCacheCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.initialDataSize = initialDataSize
  result.pInitialData = pInitialData

proc newVkShaderModuleValidationCacheCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, validationCache: VkValidationCacheEXT): VkShaderModuleValidationCacheCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.validationCache = validationCache

proc newVkPhysicalDeviceMaintenance3Properties*(sType: VkStructureType, pNext: pointer = nil, maxPerSetDescriptors: uint32, maxMemoryAllocationSize: VkDeviceSize): VkPhysicalDeviceMaintenance3Properties =
  result.sType = sType
  result.pNext = pNext
  result.maxPerSetDescriptors = maxPerSetDescriptors
  result.maxMemoryAllocationSize = maxMemoryAllocationSize

proc newVkDescriptorSetLayoutSupport*(sType: VkStructureType, pNext: pointer = nil, supported: VkBool32): VkDescriptorSetLayoutSupport =
  result.sType = sType
  result.pNext = pNext
  result.supported = supported

proc newVkPhysicalDeviceShaderDrawParametersFeatures*(sType: VkStructureType, pNext: pointer = nil, shaderDrawParameters: VkBool32): VkPhysicalDeviceShaderDrawParametersFeatures =
  result.sType = sType
  result.pNext = pNext
  result.shaderDrawParameters = shaderDrawParameters

proc newVkPhysicalDeviceShaderFloat16Int8Features*(sType: VkStructureType, pNext: pointer = nil, shaderFloat16: VkBool32, shaderInt8: VkBool32): VkPhysicalDeviceShaderFloat16Int8Features =
  result.sType = sType
  result.pNext = pNext
  result.shaderFloat16 = shaderFloat16
  result.shaderInt8 = shaderInt8

proc newVkPhysicalDeviceFloatControlsProperties*(sType: VkStructureType, pNext: pointer = nil, denormBehaviorIndependence: VkShaderFloatControlsIndependence, roundingModeIndependence: VkShaderFloatControlsIndependence, shaderSignedZeroInfNanPreserveFloat16: VkBool32, shaderSignedZeroInfNanPreserveFloat32: VkBool32, shaderSignedZeroInfNanPreserveFloat64: VkBool32, shaderDenormPreserveFloat16: VkBool32, shaderDenormPreserveFloat32: VkBool32, shaderDenormPreserveFloat64: VkBool32, shaderDenormFlushToZeroFloat16: VkBool32, shaderDenormFlushToZeroFloat32: VkBool32, shaderDenormFlushToZeroFloat64: VkBool32, shaderRoundingModeRTEFloat16: VkBool32, shaderRoundingModeRTEFloat32: VkBool32, shaderRoundingModeRTEFloat64: VkBool32, shaderRoundingModeRTZFloat16: VkBool32, shaderRoundingModeRTZFloat32: VkBool32, shaderRoundingModeRTZFloat64: VkBool32): VkPhysicalDeviceFloatControlsProperties =
  result.sType = sType
  result.pNext = pNext
  result.denormBehaviorIndependence = denormBehaviorIndependence
  result.roundingModeIndependence = roundingModeIndependence
  result.shaderSignedZeroInfNanPreserveFloat16 = shaderSignedZeroInfNanPreserveFloat16
  result.shaderSignedZeroInfNanPreserveFloat32 = shaderSignedZeroInfNanPreserveFloat32
  result.shaderSignedZeroInfNanPreserveFloat64 = shaderSignedZeroInfNanPreserveFloat64
  result.shaderDenormPreserveFloat16 = shaderDenormPreserveFloat16
  result.shaderDenormPreserveFloat32 = shaderDenormPreserveFloat32
  result.shaderDenormPreserveFloat64 = shaderDenormPreserveFloat64
  result.shaderDenormFlushToZeroFloat16 = shaderDenormFlushToZeroFloat16
  result.shaderDenormFlushToZeroFloat32 = shaderDenormFlushToZeroFloat32
  result.shaderDenormFlushToZeroFloat64 = shaderDenormFlushToZeroFloat64
  result.shaderRoundingModeRTEFloat16 = shaderRoundingModeRTEFloat16
  result.shaderRoundingModeRTEFloat32 = shaderRoundingModeRTEFloat32
  result.shaderRoundingModeRTEFloat64 = shaderRoundingModeRTEFloat64
  result.shaderRoundingModeRTZFloat16 = shaderRoundingModeRTZFloat16
  result.shaderRoundingModeRTZFloat32 = shaderRoundingModeRTZFloat32
  result.shaderRoundingModeRTZFloat64 = shaderRoundingModeRTZFloat64

proc newVkPhysicalDeviceHostQueryResetFeatures*(sType: VkStructureType, pNext: pointer = nil, hostQueryReset: VkBool32): VkPhysicalDeviceHostQueryResetFeatures =
  result.sType = sType
  result.pNext = pNext
  result.hostQueryReset = hostQueryReset

proc newVkNativeBufferUsage2ANDROID*(consumer: uint64, producer: uint64): VkNativeBufferUsage2ANDROID =
  result.consumer = consumer
  result.producer = producer

proc newVkNativeBufferANDROID*(sType: VkStructureType, pNext: pointer = nil, handle: pointer = nil, stride: int, format: int, usage: int, usage2: VkNativeBufferUsage2ANDROID): VkNativeBufferANDROID =
  result.sType = sType
  result.pNext = pNext
  result.handle = handle
  result.stride = stride
  result.format = format
  result.usage = usage
  result.usage2 = usage2

proc newVkSwapchainImageCreateInfoANDROID*(sType: VkStructureType, pNext: pointer = nil, usage: VkSwapchainImageUsageFlagsANDROID): VkSwapchainImageCreateInfoANDROID =
  result.sType = sType
  result.pNext = pNext
  result.usage = usage

proc newVkPhysicalDevicePresentationPropertiesANDROID*(sType: VkStructureType, pNext: pointer = nil, sharedImage: VkBool32): VkPhysicalDevicePresentationPropertiesANDROID =
  result.sType = sType
  result.pNext = pNext
  result.sharedImage = sharedImage

proc newVkShaderResourceUsageAMD*(numUsedVgprs: uint32, numUsedSgprs: uint32, ldsSizePerLocalWorkGroup: uint32, ldsUsageSizeInBytes: uint, scratchMemUsageInBytes: uint): VkShaderResourceUsageAMD =
  result.numUsedVgprs = numUsedVgprs
  result.numUsedSgprs = numUsedSgprs
  result.ldsSizePerLocalWorkGroup = ldsSizePerLocalWorkGroup
  result.ldsUsageSizeInBytes = ldsUsageSizeInBytes
  result.scratchMemUsageInBytes = scratchMemUsageInBytes

proc newVkShaderStatisticsInfoAMD*(shaderStageMask: VkShaderStageFlags, resourceUsage: VkShaderResourceUsageAMD, numPhysicalVgprs: uint32, numPhysicalSgprs: uint32, numAvailableVgprs: uint32, numAvailableSgprs: uint32, computeWorkGroupSize: array[3, uint32]): VkShaderStatisticsInfoAMD =
  result.shaderStageMask = shaderStageMask
  result.resourceUsage = resourceUsage
  result.numPhysicalVgprs = numPhysicalVgprs
  result.numPhysicalSgprs = numPhysicalSgprs
  result.numAvailableVgprs = numAvailableVgprs
  result.numAvailableSgprs = numAvailableSgprs
  result.computeWorkGroupSize = computeWorkGroupSize

proc newVkDeviceQueueGlobalPriorityCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, globalPriority: VkQueueGlobalPriorityEXT): VkDeviceQueueGlobalPriorityCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.globalPriority = globalPriority

proc newVkDebugUtilsObjectNameInfoEXT*(sType: VkStructureType, pNext: pointer = nil, objectType: VkObjectType, objectHandle: uint64, pObjectName: cstring): VkDebugUtilsObjectNameInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.objectType = objectType
  result.objectHandle = objectHandle
  result.pObjectName = pObjectName

proc newVkDebugUtilsObjectTagInfoEXT*(sType: VkStructureType, pNext: pointer = nil, objectType: VkObjectType, objectHandle: uint64, tagName: uint64, tagSize: uint, pTag: pointer = nil): VkDebugUtilsObjectTagInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.objectType = objectType
  result.objectHandle = objectHandle
  result.tagName = tagName
  result.tagSize = tagSize
  result.pTag = pTag

proc newVkDebugUtilsLabelEXT*(sType: VkStructureType, pNext: pointer = nil, pLabelName: cstring, color: array[4, float32]): VkDebugUtilsLabelEXT =
  result.sType = sType
  result.pNext = pNext
  result.pLabelName = pLabelName
  result.color = color

proc newVkDebugUtilsMessengerCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkDebugUtilsMessengerCreateFlagsEXT = 0.VkDebugUtilsMessengerCreateFlagsEXT, messageSeverity: VkDebugUtilsMessageSeverityFlagsEXT, messageType: VkDebugUtilsMessageTypeFlagsEXT, pfnUserCallback: PFN_vkDebugUtilsMessengerCallbackEXT, pUserData: pointer = nil): VkDebugUtilsMessengerCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.messageSeverity = messageSeverity
  result.messageType = messageType
  result.pfnUserCallback = pfnUserCallback
  result.pUserData = pUserData

proc newVkDebugUtilsMessengerCallbackDataEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkDebugUtilsMessengerCallbackDataFlagsEXT = 0.VkDebugUtilsMessengerCallbackDataFlagsEXT, pMessageIdName: cstring, messageIdNumber: int32, pMessage: cstring, queueLabelCount: uint32, pQueueLabels: ptr VkDebugUtilsLabelEXT, cmdBufLabelCount: uint32, pCmdBufLabels: ptr VkDebugUtilsLabelEXT, objectCount: uint32, pObjects: ptr VkDebugUtilsObjectNameInfoEXT): VkDebugUtilsMessengerCallbackDataEXT =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.pMessageIdName = pMessageIdName
  result.messageIdNumber = messageIdNumber
  result.pMessage = pMessage
  result.queueLabelCount = queueLabelCount
  result.pQueueLabels = pQueueLabels
  result.cmdBufLabelCount = cmdBufLabelCount
  result.pCmdBufLabels = pCmdBufLabels
  result.objectCount = objectCount
  result.pObjects = pObjects

proc newVkImportMemoryHostPointerInfoEXT*(sType: VkStructureType, pNext: pointer = nil, handleType: VkExternalMemoryHandleTypeFlagBits, pHostPointer: pointer = nil): VkImportMemoryHostPointerInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.handleType = handleType
  result.pHostPointer = pHostPointer

proc newVkMemoryHostPointerPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, memoryTypeBits: uint32): VkMemoryHostPointerPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.memoryTypeBits = memoryTypeBits

proc newVkPhysicalDeviceExternalMemoryHostPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, minImportedHostPointerAlignment: VkDeviceSize): VkPhysicalDeviceExternalMemoryHostPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.minImportedHostPointerAlignment = minImportedHostPointerAlignment

proc newVkPhysicalDeviceConservativeRasterizationPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, primitiveOverestimationSize: float32, maxExtraPrimitiveOverestimationSize: float32, extraPrimitiveOverestimationSizeGranularity: float32, primitiveUnderestimation: VkBool32, conservativePointAndLineRasterization: VkBool32, degenerateTrianglesRasterized: VkBool32, degenerateLinesRasterized: VkBool32, fullyCoveredFragmentShaderInputVariable: VkBool32, conservativeRasterizationPostDepthCoverage: VkBool32): VkPhysicalDeviceConservativeRasterizationPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.primitiveOverestimationSize = primitiveOverestimationSize
  result.maxExtraPrimitiveOverestimationSize = maxExtraPrimitiveOverestimationSize
  result.extraPrimitiveOverestimationSizeGranularity = extraPrimitiveOverestimationSizeGranularity
  result.primitiveUnderestimation = primitiveUnderestimation
  result.conservativePointAndLineRasterization = conservativePointAndLineRasterization
  result.degenerateTrianglesRasterized = degenerateTrianglesRasterized
  result.degenerateLinesRasterized = degenerateLinesRasterized
  result.fullyCoveredFragmentShaderInputVariable = fullyCoveredFragmentShaderInputVariable
  result.conservativeRasterizationPostDepthCoverage = conservativeRasterizationPostDepthCoverage

proc newVkCalibratedTimestampInfoEXT*(sType: VkStructureType, pNext: pointer = nil, timeDomain: VkTimeDomainEXT): VkCalibratedTimestampInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.timeDomain = timeDomain

proc newVkPhysicalDeviceShaderCorePropertiesAMD*(sType: VkStructureType, pNext: pointer = nil, shaderEngineCount: uint32, shaderArraysPerEngineCount: uint32, computeUnitsPerShaderArray: uint32, simdPerComputeUnit: uint32, wavefrontsPerSimd: uint32, wavefrontSize: uint32, sgprsPerSimd: uint32, minSgprAllocation: uint32, maxSgprAllocation: uint32, sgprAllocationGranularity: uint32, vgprsPerSimd: uint32, minVgprAllocation: uint32, maxVgprAllocation: uint32, vgprAllocationGranularity: uint32): VkPhysicalDeviceShaderCorePropertiesAMD =
  result.sType = sType
  result.pNext = pNext
  result.shaderEngineCount = shaderEngineCount
  result.shaderArraysPerEngineCount = shaderArraysPerEngineCount
  result.computeUnitsPerShaderArray = computeUnitsPerShaderArray
  result.simdPerComputeUnit = simdPerComputeUnit
  result.wavefrontsPerSimd = wavefrontsPerSimd
  result.wavefrontSize = wavefrontSize
  result.sgprsPerSimd = sgprsPerSimd
  result.minSgprAllocation = minSgprAllocation
  result.maxSgprAllocation = maxSgprAllocation
  result.sgprAllocationGranularity = sgprAllocationGranularity
  result.vgprsPerSimd = vgprsPerSimd
  result.minVgprAllocation = minVgprAllocation
  result.maxVgprAllocation = maxVgprAllocation
  result.vgprAllocationGranularity = vgprAllocationGranularity

proc newVkPhysicalDeviceShaderCoreProperties2AMD*(sType: VkStructureType, pNext: pointer = nil, shaderCoreFeatures: VkShaderCorePropertiesFlagsAMD, activeComputeUnitCount: uint32): VkPhysicalDeviceShaderCoreProperties2AMD =
  result.sType = sType
  result.pNext = pNext
  result.shaderCoreFeatures = shaderCoreFeatures
  result.activeComputeUnitCount = activeComputeUnitCount

proc newVkPipelineRasterizationConservativeStateCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineRasterizationConservativeStateCreateFlagsEXT = 0.VkPipelineRasterizationConservativeStateCreateFlagsEXT, conservativeRasterizationMode: VkConservativeRasterizationModeEXT, extraPrimitiveOverestimationSize: float32): VkPipelineRasterizationConservativeStateCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.conservativeRasterizationMode = conservativeRasterizationMode
  result.extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize

proc newVkPhysicalDeviceDescriptorIndexingFeatures*(sType: VkStructureType, pNext: pointer = nil, 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: VkBool32): VkPhysicalDeviceDescriptorIndexingFeatures =
  result.sType = sType
  result.pNext = pNext
  result.shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing
  result.shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing
  result.shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing
  result.shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing
  result.shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing
  result.shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing
  result.shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing
  result.shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing
  result.shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing
  result.shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing
  result.descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind
  result.descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind
  result.descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind
  result.descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind
  result.descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind
  result.descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind
  result.descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending
  result.descriptorBindingPartiallyBound = descriptorBindingPartiallyBound
  result.descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount
  result.runtimeDescriptorArray = runtimeDescriptorArray

proc newVkPhysicalDeviceDescriptorIndexingProperties*(sType: VkStructureType, pNext: pointer = nil, maxUpdateAfterBindDescriptorsInAllPools: uint32, shaderUniformBufferArrayNonUniformIndexingNative: VkBool32, shaderSampledImageArrayNonUniformIndexingNative: VkBool32, shaderStorageBufferArrayNonUniformIndexingNative: VkBool32, shaderStorageImageArrayNonUniformIndexingNative: VkBool32, shaderInputAttachmentArrayNonUniformIndexingNative: VkBool32, robustBufferAccessUpdateAfterBind: VkBool32, quadDivergentImplicitLod: VkBool32, maxPerStageDescriptorUpdateAfterBindSamplers: uint32, maxPerStageDescriptorUpdateAfterBindUniformBuffers: uint32, maxPerStageDescriptorUpdateAfterBindStorageBuffers: uint32, maxPerStageDescriptorUpdateAfterBindSampledImages: uint32, maxPerStageDescriptorUpdateAfterBindStorageImages: uint32, maxPerStageDescriptorUpdateAfterBindInputAttachments: uint32, maxPerStageUpdateAfterBindResources: uint32, maxDescriptorSetUpdateAfterBindSamplers: uint32, maxDescriptorSetUpdateAfterBindUniformBuffers: uint32, maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: uint32, maxDescriptorSetUpdateAfterBindStorageBuffers: uint32, maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: uint32, maxDescriptorSetUpdateAfterBindSampledImages: uint32, maxDescriptorSetUpdateAfterBindStorageImages: uint32, maxDescriptorSetUpdateAfterBindInputAttachments: uint32): VkPhysicalDeviceDescriptorIndexingProperties =
  result.sType = sType
  result.pNext = pNext
  result.maxUpdateAfterBindDescriptorsInAllPools = maxUpdateAfterBindDescriptorsInAllPools
  result.shaderUniformBufferArrayNonUniformIndexingNative = shaderUniformBufferArrayNonUniformIndexingNative
  result.shaderSampledImageArrayNonUniformIndexingNative = shaderSampledImageArrayNonUniformIndexingNative
  result.shaderStorageBufferArrayNonUniformIndexingNative = shaderStorageBufferArrayNonUniformIndexingNative
  result.shaderStorageImageArrayNonUniformIndexingNative = shaderStorageImageArrayNonUniformIndexingNative
  result.shaderInputAttachmentArrayNonUniformIndexingNative = shaderInputAttachmentArrayNonUniformIndexingNative
  result.robustBufferAccessUpdateAfterBind = robustBufferAccessUpdateAfterBind
  result.quadDivergentImplicitLod = quadDivergentImplicitLod
  result.maxPerStageDescriptorUpdateAfterBindSamplers = maxPerStageDescriptorUpdateAfterBindSamplers
  result.maxPerStageDescriptorUpdateAfterBindUniformBuffers = maxPerStageDescriptorUpdateAfterBindUniformBuffers
  result.maxPerStageDescriptorUpdateAfterBindStorageBuffers = maxPerStageDescriptorUpdateAfterBindStorageBuffers
  result.maxPerStageDescriptorUpdateAfterBindSampledImages = maxPerStageDescriptorUpdateAfterBindSampledImages
  result.maxPerStageDescriptorUpdateAfterBindStorageImages = maxPerStageDescriptorUpdateAfterBindStorageImages
  result.maxPerStageDescriptorUpdateAfterBindInputAttachments = maxPerStageDescriptorUpdateAfterBindInputAttachments
  result.maxPerStageUpdateAfterBindResources = maxPerStageUpdateAfterBindResources
  result.maxDescriptorSetUpdateAfterBindSamplers = maxDescriptorSetUpdateAfterBindSamplers
  result.maxDescriptorSetUpdateAfterBindUniformBuffers = maxDescriptorSetUpdateAfterBindUniformBuffers
  result.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = maxDescriptorSetUpdateAfterBindUniformBuffersDynamic
  result.maxDescriptorSetUpdateAfterBindStorageBuffers = maxDescriptorSetUpdateAfterBindStorageBuffers
  result.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = maxDescriptorSetUpdateAfterBindStorageBuffersDynamic
  result.maxDescriptorSetUpdateAfterBindSampledImages = maxDescriptorSetUpdateAfterBindSampledImages
  result.maxDescriptorSetUpdateAfterBindStorageImages = maxDescriptorSetUpdateAfterBindStorageImages
  result.maxDescriptorSetUpdateAfterBindInputAttachments = maxDescriptorSetUpdateAfterBindInputAttachments

proc newVkDescriptorSetLayoutBindingFlagsCreateInfo*(sType: VkStructureType, pNext: pointer = nil, bindingCount: uint32, pBindingFlags: ptr VkDescriptorBindingFlags): VkDescriptorSetLayoutBindingFlagsCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.bindingCount = bindingCount
  result.pBindingFlags = pBindingFlags

proc newVkDescriptorSetVariableDescriptorCountAllocateInfo*(sType: VkStructureType, pNext: pointer = nil, descriptorSetCount: uint32, pDescriptorCounts: ptr uint32): VkDescriptorSetVariableDescriptorCountAllocateInfo =
  result.sType = sType
  result.pNext = pNext
  result.descriptorSetCount = descriptorSetCount
  result.pDescriptorCounts = pDescriptorCounts

proc newVkDescriptorSetVariableDescriptorCountLayoutSupport*(sType: VkStructureType, pNext: pointer = nil, maxVariableDescriptorCount: uint32): VkDescriptorSetVariableDescriptorCountLayoutSupport =
  result.sType = sType
  result.pNext = pNext
  result.maxVariableDescriptorCount = maxVariableDescriptorCount

proc newVkAttachmentDescription2*(sType: VkStructureType, pNext: pointer = nil, flags: VkAttachmentDescriptionFlags = 0.VkAttachmentDescriptionFlags, format: VkFormat, samples: VkSampleCountFlagBits, loadOp: VkAttachmentLoadOp, storeOp: VkAttachmentStoreOp, stencilLoadOp: VkAttachmentLoadOp, stencilStoreOp: VkAttachmentStoreOp, initialLayout: VkImageLayout, finalLayout: VkImageLayout): VkAttachmentDescription2 =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.format = format
  result.samples = samples
  result.loadOp = loadOp
  result.storeOp = storeOp
  result.stencilLoadOp = stencilLoadOp
  result.stencilStoreOp = stencilStoreOp
  result.initialLayout = initialLayout
  result.finalLayout = finalLayout

proc newVkAttachmentReference2*(sType: VkStructureType, pNext: pointer = nil, attachment: uint32, layout: VkImageLayout, aspectMask: VkImageAspectFlags): VkAttachmentReference2 =
  result.sType = sType
  result.pNext = pNext
  result.attachment = attachment
  result.layout = layout
  result.aspectMask = aspectMask

proc newVkSubpassDescription2*(sType: VkStructureType, pNext: pointer = nil, flags: VkSubpassDescriptionFlags = 0.VkSubpassDescriptionFlags, pipelineBindPoint: VkPipelineBindPoint, viewMask: uint32, inputAttachmentCount: uint32, pInputAttachments: ptr VkAttachmentReference2, colorAttachmentCount: uint32, pColorAttachments: ptr VkAttachmentReference2, pResolveAttachments: ptr VkAttachmentReference2, pDepthStencilAttachment: ptr VkAttachmentReference2, preserveAttachmentCount: uint32, pPreserveAttachments: ptr uint32): VkSubpassDescription2 =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.pipelineBindPoint = pipelineBindPoint
  result.viewMask = viewMask
  result.inputAttachmentCount = inputAttachmentCount
  result.pInputAttachments = pInputAttachments
  result.colorAttachmentCount = colorAttachmentCount
  result.pColorAttachments = pColorAttachments
  result.pResolveAttachments = pResolveAttachments
  result.pDepthStencilAttachment = pDepthStencilAttachment
  result.preserveAttachmentCount = preserveAttachmentCount
  result.pPreserveAttachments = pPreserveAttachments

proc newVkSubpassDependency2*(sType: VkStructureType, pNext: pointer = nil, srcSubpass: uint32, dstSubpass: uint32, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, srcAccessMask: VkAccessFlags, dstAccessMask: VkAccessFlags, dependencyFlags: VkDependencyFlags, viewOffset: int32): VkSubpassDependency2 =
  result.sType = sType
  result.pNext = pNext
  result.srcSubpass = srcSubpass
  result.dstSubpass = dstSubpass
  result.srcStageMask = srcStageMask
  result.dstStageMask = dstStageMask
  result.srcAccessMask = srcAccessMask
  result.dstAccessMask = dstAccessMask
  result.dependencyFlags = dependencyFlags
  result.viewOffset = viewOffset

proc newVkRenderPassCreateInfo2*(sType: VkStructureType, pNext: pointer = nil, flags: VkRenderPassCreateFlags = 0.VkRenderPassCreateFlags, attachmentCount: uint32, pAttachments: ptr VkAttachmentDescription2, subpassCount: uint32, pSubpasses: ptr VkSubpassDescription2, dependencyCount: uint32, pDependencies: ptr VkSubpassDependency2, correlatedViewMaskCount: uint32, pCorrelatedViewMasks: ptr uint32): VkRenderPassCreateInfo2 =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.attachmentCount = attachmentCount
  result.pAttachments = pAttachments
  result.subpassCount = subpassCount
  result.pSubpasses = pSubpasses
  result.dependencyCount = dependencyCount
  result.pDependencies = pDependencies
  result.correlatedViewMaskCount = correlatedViewMaskCount
  result.pCorrelatedViewMasks = pCorrelatedViewMasks

proc newVkSubpassBeginInfo*(sType: VkStructureType, pNext: pointer = nil, contents: VkSubpassContents): VkSubpassBeginInfo =
  result.sType = sType
  result.pNext = pNext
  result.contents = contents

proc newVkSubpassEndInfo*(sType: VkStructureType, pNext: pointer = nil): VkSubpassEndInfo =
  result.sType = sType
  result.pNext = pNext

proc newVkPhysicalDeviceTimelineSemaphoreFeatures*(sType: VkStructureType, pNext: pointer = nil, timelineSemaphore: VkBool32): VkPhysicalDeviceTimelineSemaphoreFeatures =
  result.sType = sType
  result.pNext = pNext
  result.timelineSemaphore = timelineSemaphore

proc newVkPhysicalDeviceTimelineSemaphoreProperties*(sType: VkStructureType, pNext: pointer = nil, maxTimelineSemaphoreValueDifference: uint64): VkPhysicalDeviceTimelineSemaphoreProperties =
  result.sType = sType
  result.pNext = pNext
  result.maxTimelineSemaphoreValueDifference = maxTimelineSemaphoreValueDifference

proc newVkSemaphoreTypeCreateInfo*(sType: VkStructureType, pNext: pointer = nil, semaphoreType: VkSemaphoreType, initialValue: uint64): VkSemaphoreTypeCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.semaphoreType = semaphoreType
  result.initialValue = initialValue

proc newVkTimelineSemaphoreSubmitInfo*(sType: VkStructureType, pNext: pointer = nil, waitSemaphoreValueCount: uint32, pWaitSemaphoreValues: ptr uint64, signalSemaphoreValueCount: uint32, pSignalSemaphoreValues: ptr uint64): VkTimelineSemaphoreSubmitInfo =
  result.sType = sType
  result.pNext = pNext
  result.waitSemaphoreValueCount = waitSemaphoreValueCount
  result.pWaitSemaphoreValues = pWaitSemaphoreValues
  result.signalSemaphoreValueCount = signalSemaphoreValueCount
  result.pSignalSemaphoreValues = pSignalSemaphoreValues

proc newVkSemaphoreWaitInfo*(sType: VkStructureType, pNext: pointer = nil, flags: VkSemaphoreWaitFlags = 0.VkSemaphoreWaitFlags, semaphoreCount: uint32, pSemaphores: ptr VkSemaphore, pValues: ptr uint64): VkSemaphoreWaitInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.semaphoreCount = semaphoreCount
  result.pSemaphores = pSemaphores
  result.pValues = pValues

proc newVkSemaphoreSignalInfo*(sType: VkStructureType, pNext: pointer = nil, semaphore: VkSemaphore, value: uint64): VkSemaphoreSignalInfo =
  result.sType = sType
  result.pNext = pNext
  result.semaphore = semaphore
  result.value = value

proc newVkVertexInputBindingDivisorDescriptionEXT*(binding: uint32, divisor: uint32): VkVertexInputBindingDivisorDescriptionEXT =
  result.binding = binding
  result.divisor = divisor

proc newVkPipelineVertexInputDivisorStateCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, vertexBindingDivisorCount: uint32, pVertexBindingDivisors: ptr VkVertexInputBindingDivisorDescriptionEXT): VkPipelineVertexInputDivisorStateCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.vertexBindingDivisorCount = vertexBindingDivisorCount
  result.pVertexBindingDivisors = pVertexBindingDivisors

proc newVkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, maxVertexAttribDivisor: uint32): VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.maxVertexAttribDivisor = maxVertexAttribDivisor

proc newVkPhysicalDevicePCIBusInfoPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, pciDomain: uint32, pciBus: uint32, pciDevice: uint32, pciFunction: uint32): VkPhysicalDevicePCIBusInfoPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.pciDomain = pciDomain
  result.pciBus = pciBus
  result.pciDevice = pciDevice
  result.pciFunction = pciFunction

proc newVkImportAndroidHardwareBufferInfoANDROID*(sType: VkStructureType, pNext: pointer = nil, buffer: ptr AHardwareBuffer): VkImportAndroidHardwareBufferInfoANDROID =
  result.sType = sType
  result.pNext = pNext
  result.buffer = buffer

proc newVkAndroidHardwareBufferUsageANDROID*(sType: VkStructureType, pNext: pointer = nil, androidHardwareBufferUsage: uint64): VkAndroidHardwareBufferUsageANDROID =
  result.sType = sType
  result.pNext = pNext
  result.androidHardwareBufferUsage = androidHardwareBufferUsage

proc newVkAndroidHardwareBufferPropertiesANDROID*(sType: VkStructureType, pNext: pointer = nil, allocationSize: VkDeviceSize, memoryTypeBits: uint32): VkAndroidHardwareBufferPropertiesANDROID =
  result.sType = sType
  result.pNext = pNext
  result.allocationSize = allocationSize
  result.memoryTypeBits = memoryTypeBits

proc newVkMemoryGetAndroidHardwareBufferInfoANDROID*(sType: VkStructureType, pNext: pointer = nil, memory: VkDeviceMemory): VkMemoryGetAndroidHardwareBufferInfoANDROID =
  result.sType = sType
  result.pNext = pNext
  result.memory = memory

proc newVkAndroidHardwareBufferFormatPropertiesANDROID*(sType: VkStructureType, pNext: pointer = nil, format: VkFormat, externalFormat: uint64, formatFeatures: VkFormatFeatureFlags, samplerYcbcrConversionComponents: VkComponentMapping, suggestedYcbcrModel: VkSamplerYcbcrModelConversion, suggestedYcbcrRange: VkSamplerYcbcrRange, suggestedXChromaOffset: VkChromaLocation, suggestedYChromaOffset: VkChromaLocation): VkAndroidHardwareBufferFormatPropertiesANDROID =
  result.sType = sType
  result.pNext = pNext
  result.format = format
  result.externalFormat = externalFormat
  result.formatFeatures = formatFeatures
  result.samplerYcbcrConversionComponents = samplerYcbcrConversionComponents
  result.suggestedYcbcrModel = suggestedYcbcrModel
  result.suggestedYcbcrRange = suggestedYcbcrRange
  result.suggestedXChromaOffset = suggestedXChromaOffset
  result.suggestedYChromaOffset = suggestedYChromaOffset

proc newVkCommandBufferInheritanceConditionalRenderingInfoEXT*(sType: VkStructureType, pNext: pointer = nil, conditionalRenderingEnable: VkBool32): VkCommandBufferInheritanceConditionalRenderingInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.conditionalRenderingEnable = conditionalRenderingEnable

proc newVkExternalFormatANDROID*(sType: VkStructureType, pNext: pointer = nil, externalFormat: uint64): VkExternalFormatANDROID =
  result.sType = sType
  result.pNext = pNext
  result.externalFormat = externalFormat

proc newVkPhysicalDevice8BitStorageFeatures*(sType: VkStructureType, pNext: pointer = nil, storageBuffer8BitAccess: VkBool32, uniformAndStorageBuffer8BitAccess: VkBool32, storagePushConstant8: VkBool32): VkPhysicalDevice8BitStorageFeatures =
  result.sType = sType
  result.pNext = pNext
  result.storageBuffer8BitAccess = storageBuffer8BitAccess
  result.uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess
  result.storagePushConstant8 = storagePushConstant8

proc newVkPhysicalDeviceConditionalRenderingFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, conditionalRendering: VkBool32, inheritedConditionalRendering: VkBool32): VkPhysicalDeviceConditionalRenderingFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.conditionalRendering = conditionalRendering
  result.inheritedConditionalRendering = inheritedConditionalRendering

proc newVkPhysicalDeviceVulkanMemoryModelFeatures*(sType: VkStructureType, pNext: pointer = nil, vulkanMemoryModel: VkBool32, vulkanMemoryModelDeviceScope: VkBool32, vulkanMemoryModelAvailabilityVisibilityChains: VkBool32): VkPhysicalDeviceVulkanMemoryModelFeatures =
  result.sType = sType
  result.pNext = pNext
  result.vulkanMemoryModel = vulkanMemoryModel
  result.vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope
  result.vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains

proc newVkPhysicalDeviceShaderAtomicInt64Features*(sType: VkStructureType, pNext: pointer = nil, shaderBufferInt64Atomics: VkBool32, shaderSharedInt64Atomics: VkBool32): VkPhysicalDeviceShaderAtomicInt64Features =
  result.sType = sType
  result.pNext = pNext
  result.shaderBufferInt64Atomics = shaderBufferInt64Atomics
  result.shaderSharedInt64Atomics = shaderSharedInt64Atomics

proc newVkPhysicalDeviceShaderAtomicFloatFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, shaderBufferFloat32Atomics: VkBool32, shaderBufferFloat32AtomicAdd: VkBool32, shaderBufferFloat64Atomics: VkBool32, shaderBufferFloat64AtomicAdd: VkBool32, shaderSharedFloat32Atomics: VkBool32, shaderSharedFloat32AtomicAdd: VkBool32, shaderSharedFloat64Atomics: VkBool32, shaderSharedFloat64AtomicAdd: VkBool32, shaderImageFloat32Atomics: VkBool32, shaderImageFloat32AtomicAdd: VkBool32, sparseImageFloat32Atomics: VkBool32, sparseImageFloat32AtomicAdd: VkBool32): VkPhysicalDeviceShaderAtomicFloatFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.shaderBufferFloat32Atomics = shaderBufferFloat32Atomics
  result.shaderBufferFloat32AtomicAdd = shaderBufferFloat32AtomicAdd
  result.shaderBufferFloat64Atomics = shaderBufferFloat64Atomics
  result.shaderBufferFloat64AtomicAdd = shaderBufferFloat64AtomicAdd
  result.shaderSharedFloat32Atomics = shaderSharedFloat32Atomics
  result.shaderSharedFloat32AtomicAdd = shaderSharedFloat32AtomicAdd
  result.shaderSharedFloat64Atomics = shaderSharedFloat64Atomics
  result.shaderSharedFloat64AtomicAdd = shaderSharedFloat64AtomicAdd
  result.shaderImageFloat32Atomics = shaderImageFloat32Atomics
  result.shaderImageFloat32AtomicAdd = shaderImageFloat32AtomicAdd
  result.sparseImageFloat32Atomics = sparseImageFloat32Atomics
  result.sparseImageFloat32AtomicAdd = sparseImageFloat32AtomicAdd

proc newVkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, vertexAttributeInstanceRateDivisor: VkBool32, vertexAttributeInstanceRateZeroDivisor: VkBool32): VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor
  result.vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor

proc newVkQueueFamilyCheckpointPropertiesNV*(sType: VkStructureType, pNext: pointer = nil, checkpointExecutionStageMask: VkPipelineStageFlags): VkQueueFamilyCheckpointPropertiesNV =
  result.sType = sType
  result.pNext = pNext
  result.checkpointExecutionStageMask = checkpointExecutionStageMask

proc newVkCheckpointDataNV*(sType: VkStructureType, pNext: pointer = nil, stage: VkPipelineStageFlagBits, pCheckpointMarker: pointer = nil): VkCheckpointDataNV =
  result.sType = sType
  result.pNext = pNext
  result.stage = stage
  result.pCheckpointMarker = pCheckpointMarker

proc newVkPhysicalDeviceDepthStencilResolveProperties*(sType: VkStructureType, pNext: pointer = nil, supportedDepthResolveModes: VkResolveModeFlags, supportedStencilResolveModes: VkResolveModeFlags, independentResolveNone: VkBool32, independentResolve: VkBool32): VkPhysicalDeviceDepthStencilResolveProperties =
  result.sType = sType
  result.pNext = pNext
  result.supportedDepthResolveModes = supportedDepthResolveModes
  result.supportedStencilResolveModes = supportedStencilResolveModes
  result.independentResolveNone = independentResolveNone
  result.independentResolve = independentResolve

proc newVkSubpassDescriptionDepthStencilResolve*(sType: VkStructureType, pNext: pointer = nil, depthResolveMode: VkResolveModeFlagBits, stencilResolveMode: VkResolveModeFlagBits, pDepthStencilResolveAttachment: ptr VkAttachmentReference2): VkSubpassDescriptionDepthStencilResolve =
  result.sType = sType
  result.pNext = pNext
  result.depthResolveMode = depthResolveMode
  result.stencilResolveMode = stencilResolveMode
  result.pDepthStencilResolveAttachment = pDepthStencilResolveAttachment

proc newVkImageViewASTCDecodeModeEXT*(sType: VkStructureType, pNext: pointer = nil, decodeMode: VkFormat): VkImageViewASTCDecodeModeEXT =
  result.sType = sType
  result.pNext = pNext
  result.decodeMode = decodeMode

proc newVkPhysicalDeviceASTCDecodeFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, decodeModeSharedExponent: VkBool32): VkPhysicalDeviceASTCDecodeFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.decodeModeSharedExponent = decodeModeSharedExponent

proc newVkPhysicalDeviceTransformFeedbackFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, transformFeedback: VkBool32, geometryStreams: VkBool32): VkPhysicalDeviceTransformFeedbackFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.transformFeedback = transformFeedback
  result.geometryStreams = geometryStreams

proc newVkPhysicalDeviceTransformFeedbackPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, maxTransformFeedbackStreams: uint32, maxTransformFeedbackBuffers: uint32, maxTransformFeedbackBufferSize: VkDeviceSize, maxTransformFeedbackStreamDataSize: uint32, maxTransformFeedbackBufferDataSize: uint32, maxTransformFeedbackBufferDataStride: uint32, transformFeedbackQueries: VkBool32, transformFeedbackStreamsLinesTriangles: VkBool32, transformFeedbackRasterizationStreamSelect: VkBool32, transformFeedbackDraw: VkBool32): VkPhysicalDeviceTransformFeedbackPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.maxTransformFeedbackStreams = maxTransformFeedbackStreams
  result.maxTransformFeedbackBuffers = maxTransformFeedbackBuffers
  result.maxTransformFeedbackBufferSize = maxTransformFeedbackBufferSize
  result.maxTransformFeedbackStreamDataSize = maxTransformFeedbackStreamDataSize
  result.maxTransformFeedbackBufferDataSize = maxTransformFeedbackBufferDataSize
  result.maxTransformFeedbackBufferDataStride = maxTransformFeedbackBufferDataStride
  result.transformFeedbackQueries = transformFeedbackQueries
  result.transformFeedbackStreamsLinesTriangles = transformFeedbackStreamsLinesTriangles
  result.transformFeedbackRasterizationStreamSelect = transformFeedbackRasterizationStreamSelect
  result.transformFeedbackDraw = transformFeedbackDraw

proc newVkPipelineRasterizationStateStreamCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineRasterizationStateStreamCreateFlagsEXT = 0.VkPipelineRasterizationStateStreamCreateFlagsEXT, rasterizationStream: uint32): VkPipelineRasterizationStateStreamCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.rasterizationStream = rasterizationStream

proc newVkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, representativeFragmentTest: VkBool32): VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV =
  result.sType = sType
  result.pNext = pNext
  result.representativeFragmentTest = representativeFragmentTest

proc newVkPipelineRepresentativeFragmentTestStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, representativeFragmentTestEnable: VkBool32): VkPipelineRepresentativeFragmentTestStateCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.representativeFragmentTestEnable = representativeFragmentTestEnable

proc newVkPhysicalDeviceExclusiveScissorFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, exclusiveScissor: VkBool32): VkPhysicalDeviceExclusiveScissorFeaturesNV =
  result.sType = sType
  result.pNext = pNext
  result.exclusiveScissor = exclusiveScissor

proc newVkPipelineViewportExclusiveScissorStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, exclusiveScissorCount: uint32, pExclusiveScissors: ptr VkRect2D): VkPipelineViewportExclusiveScissorStateCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.exclusiveScissorCount = exclusiveScissorCount
  result.pExclusiveScissors = pExclusiveScissors

proc newVkPhysicalDeviceCornerSampledImageFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, cornerSampledImage: VkBool32): VkPhysicalDeviceCornerSampledImageFeaturesNV =
  result.sType = sType
  result.pNext = pNext
  result.cornerSampledImage = cornerSampledImage

proc newVkPhysicalDeviceComputeShaderDerivativesFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, computeDerivativeGroupQuads: VkBool32, computeDerivativeGroupLinear: VkBool32): VkPhysicalDeviceComputeShaderDerivativesFeaturesNV =
  result.sType = sType
  result.pNext = pNext
  result.computeDerivativeGroupQuads = computeDerivativeGroupQuads
  result.computeDerivativeGroupLinear = computeDerivativeGroupLinear

proc newVkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, fragmentShaderBarycentric: VkBool32): VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV =
  result.sType = sType
  result.pNext = pNext
  result.fragmentShaderBarycentric = fragmentShaderBarycentric

proc newVkPhysicalDeviceShaderImageFootprintFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, imageFootprint: VkBool32): VkPhysicalDeviceShaderImageFootprintFeaturesNV =
  result.sType = sType
  result.pNext = pNext
  result.imageFootprint = imageFootprint

proc newVkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, dedicatedAllocationImageAliasing: VkBool32): VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV =
  result.sType = sType
  result.pNext = pNext
  result.dedicatedAllocationImageAliasing = dedicatedAllocationImageAliasing

proc newVkShadingRatePaletteNV*(shadingRatePaletteEntryCount: uint32, pShadingRatePaletteEntries: ptr VkShadingRatePaletteEntryNV): VkShadingRatePaletteNV =
  result.shadingRatePaletteEntryCount = shadingRatePaletteEntryCount
  result.pShadingRatePaletteEntries = pShadingRatePaletteEntries

proc newVkPipelineViewportShadingRateImageStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, shadingRateImageEnable: VkBool32, viewportCount: uint32, pShadingRatePalettes: ptr VkShadingRatePaletteNV): VkPipelineViewportShadingRateImageStateCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.shadingRateImageEnable = shadingRateImageEnable
  result.viewportCount = viewportCount
  result.pShadingRatePalettes = pShadingRatePalettes

proc newVkPhysicalDeviceShadingRateImageFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, shadingRateImage: VkBool32, shadingRateCoarseSampleOrder: VkBool32): VkPhysicalDeviceShadingRateImageFeaturesNV =
  result.sType = sType
  result.pNext = pNext
  result.shadingRateImage = shadingRateImage
  result.shadingRateCoarseSampleOrder = shadingRateCoarseSampleOrder

proc newVkPhysicalDeviceShadingRateImagePropertiesNV*(sType: VkStructureType, pNext: pointer = nil, shadingRateTexelSize: VkExtent2D, shadingRatePaletteSize: uint32, shadingRateMaxCoarseSamples: uint32): VkPhysicalDeviceShadingRateImagePropertiesNV =
  result.sType = sType
  result.pNext = pNext
  result.shadingRateTexelSize = shadingRateTexelSize
  result.shadingRatePaletteSize = shadingRatePaletteSize
  result.shadingRateMaxCoarseSamples = shadingRateMaxCoarseSamples

proc newVkCoarseSampleLocationNV*(pixelX: uint32, pixelY: uint32, sample: uint32): VkCoarseSampleLocationNV =
  result.pixelX = pixelX
  result.pixelY = pixelY
  result.sample = sample

proc newVkCoarseSampleOrderCustomNV*(shadingRate: VkShadingRatePaletteEntryNV, sampleCount: uint32, sampleLocationCount: uint32, pSampleLocations: ptr VkCoarseSampleLocationNV): VkCoarseSampleOrderCustomNV =
  result.shadingRate = shadingRate
  result.sampleCount = sampleCount
  result.sampleLocationCount = sampleLocationCount
  result.pSampleLocations = pSampleLocations

proc newVkPipelineViewportCoarseSampleOrderStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: uint32, pCustomSampleOrders: ptr VkCoarseSampleOrderCustomNV): VkPipelineViewportCoarseSampleOrderStateCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.sampleOrderType = sampleOrderType
  result.customSampleOrderCount = customSampleOrderCount
  result.pCustomSampleOrders = pCustomSampleOrders

proc newVkPhysicalDeviceMeshShaderFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, taskShader: VkBool32, meshShader: VkBool32): VkPhysicalDeviceMeshShaderFeaturesNV =
  result.sType = sType
  result.pNext = pNext
  result.taskShader = taskShader
  result.meshShader = meshShader

proc newVkPhysicalDeviceMeshShaderPropertiesNV*(sType: VkStructureType, pNext: pointer = nil, maxDrawMeshTasksCount: uint32, maxTaskWorkGroupInvocations: uint32, maxTaskWorkGroupSize: array[3, uint32], maxTaskTotalMemorySize: uint32, maxTaskOutputCount: uint32, maxMeshWorkGroupInvocations: uint32, maxMeshWorkGroupSize: array[3, uint32], maxMeshTotalMemorySize: uint32, maxMeshOutputVertices: uint32, maxMeshOutputPrimitives: uint32, maxMeshMultiviewViewCount: uint32, meshOutputPerVertexGranularity: uint32, meshOutputPerPrimitiveGranularity: uint32): VkPhysicalDeviceMeshShaderPropertiesNV =
  result.sType = sType
  result.pNext = pNext
  result.maxDrawMeshTasksCount = maxDrawMeshTasksCount
  result.maxTaskWorkGroupInvocations = maxTaskWorkGroupInvocations
  result.maxTaskWorkGroupSize = maxTaskWorkGroupSize
  result.maxTaskTotalMemorySize = maxTaskTotalMemorySize
  result.maxTaskOutputCount = maxTaskOutputCount
  result.maxMeshWorkGroupInvocations = maxMeshWorkGroupInvocations
  result.maxMeshWorkGroupSize = maxMeshWorkGroupSize
  result.maxMeshTotalMemorySize = maxMeshTotalMemorySize
  result.maxMeshOutputVertices = maxMeshOutputVertices
  result.maxMeshOutputPrimitives = maxMeshOutputPrimitives
  result.maxMeshMultiviewViewCount = maxMeshMultiviewViewCount
  result.meshOutputPerVertexGranularity = meshOutputPerVertexGranularity
  result.meshOutputPerPrimitiveGranularity = meshOutputPerPrimitiveGranularity

proc newVkDrawMeshTasksIndirectCommandNV*(taskCount: uint32, firstTask: uint32): VkDrawMeshTasksIndirectCommandNV =
  result.taskCount = taskCount
  result.firstTask = firstTask

proc newVkRayTracingShaderGroupCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, `type`: VkRayTracingShaderGroupTypeKHR, generalShader: uint32, closestHitShader: uint32, anyHitShader: uint32, intersectionShader: uint32): VkRayTracingShaderGroupCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.`type` = `type`
  result.generalShader = generalShader
  result.closestHitShader = closestHitShader
  result.anyHitShader = anyHitShader
  result.intersectionShader = intersectionShader

proc newVkRayTracingShaderGroupCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, `type`: VkRayTracingShaderGroupTypeKHR, generalShader: uint32, closestHitShader: uint32, anyHitShader: uint32, intersectionShader: uint32, pShaderGroupCaptureReplayHandle: pointer = nil): VkRayTracingShaderGroupCreateInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.`type` = `type`
  result.generalShader = generalShader
  result.closestHitShader = closestHitShader
  result.anyHitShader = anyHitShader
  result.intersectionShader = intersectionShader
  result.pShaderGroupCaptureReplayHandle = pShaderGroupCaptureReplayHandle

proc newVkRayTracingPipelineCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineCreateFlags = 0.VkPipelineCreateFlags, stageCount: uint32, pStages: ptr VkPipelineShaderStageCreateInfo, groupCount: uint32, pGroups: ptr VkRayTracingShaderGroupCreateInfoNV, maxRecursionDepth: uint32, layout: VkPipelineLayout, basePipelineHandle: VkPipeline, basePipelineIndex: int32): VkRayTracingPipelineCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.stageCount = stageCount
  result.pStages = pStages
  result.groupCount = groupCount
  result.pGroups = pGroups
  result.maxRecursionDepth = maxRecursionDepth
  result.layout = layout
  result.basePipelineHandle = basePipelineHandle
  result.basePipelineIndex = basePipelineIndex

proc newVkRayTracingPipelineCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineCreateFlags = 0.VkPipelineCreateFlags, stageCount: uint32, pStages: ptr VkPipelineShaderStageCreateInfo, groupCount: uint32, pGroups: ptr VkRayTracingShaderGroupCreateInfoKHR, maxRecursionDepth: uint32, libraries: VkPipelineLibraryCreateInfoKHR, pLibraryInterface: ptr VkRayTracingPipelineInterfaceCreateInfoKHR, layout: VkPipelineLayout, basePipelineHandle: VkPipeline, basePipelineIndex: int32): VkRayTracingPipelineCreateInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.stageCount = stageCount
  result.pStages = pStages
  result.groupCount = groupCount
  result.pGroups = pGroups
  result.maxRecursionDepth = maxRecursionDepth
  result.libraries = libraries
  result.pLibraryInterface = pLibraryInterface
  result.layout = layout
  result.basePipelineHandle = basePipelineHandle
  result.basePipelineIndex = basePipelineIndex

proc newVkGeometryTrianglesNV*(sType: VkStructureType, pNext: pointer = nil, vertexData: VkBuffer, vertexOffset: VkDeviceSize, vertexCount: uint32, vertexStride: VkDeviceSize, vertexFormat: VkFormat, indexData: VkBuffer, indexOffset: VkDeviceSize, indexCount: uint32, indexType: VkIndexType, transformData: VkBuffer, transformOffset: VkDeviceSize): VkGeometryTrianglesNV =
  result.sType = sType
  result.pNext = pNext
  result.vertexData = vertexData
  result.vertexOffset = vertexOffset
  result.vertexCount = vertexCount
  result.vertexStride = vertexStride
  result.vertexFormat = vertexFormat
  result.indexData = indexData
  result.indexOffset = indexOffset
  result.indexCount = indexCount
  result.indexType = indexType
  result.transformData = transformData
  result.transformOffset = transformOffset

proc newVkGeometryAABBNV*(sType: VkStructureType, pNext: pointer = nil, aabbData: VkBuffer, numAABBs: uint32, stride: uint32, offset: VkDeviceSize): VkGeometryAABBNV =
  result.sType = sType
  result.pNext = pNext
  result.aabbData = aabbData
  result.numAABBs = numAABBs
  result.stride = stride
  result.offset = offset

proc newVkGeometryDataNV*(triangles: VkGeometryTrianglesNV, aabbs: VkGeometryAABBNV): VkGeometryDataNV =
  result.triangles = triangles
  result.aabbs = aabbs

proc newVkGeometryNV*(sType: VkStructureType, pNext: pointer = nil, geometryType: VkGeometryTypeKHR, geometry: VkGeometryDataNV, flags: VkGeometryFlagsKHR = 0.VkGeometryFlagsKHR): VkGeometryNV =
  result.sType = sType
  result.pNext = pNext
  result.geometryType = geometryType
  result.geometry = geometry
  result.flags = flags

proc newVkAccelerationStructureInfoNV*(sType: VkStructureType, pNext: pointer = nil, `type`: VkAccelerationStructureTypeNV, flags: VkBuildAccelerationStructureFlagsNV = 0.VkBuildAccelerationStructureFlagsNV, instanceCount: uint32, geometryCount: uint32, pGeometries: ptr VkGeometryNV): VkAccelerationStructureInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.`type` = `type`
  result.flags = flags
  result.instanceCount = instanceCount
  result.geometryCount = geometryCount
  result.pGeometries = pGeometries

proc newVkAccelerationStructureCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, compactedSize: VkDeviceSize, info: VkAccelerationStructureInfoNV): VkAccelerationStructureCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.compactedSize = compactedSize
  result.info = info

proc newVkBindAccelerationStructureMemoryInfoKHR*(sType: VkStructureType, pNext: pointer = nil, accelerationStructure: VkAccelerationStructureKHR, memory: VkDeviceMemory, memoryOffset: VkDeviceSize, deviceIndexCount: uint32, pDeviceIndices: ptr uint32): VkBindAccelerationStructureMemoryInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.accelerationStructure = accelerationStructure
  result.memory = memory
  result.memoryOffset = memoryOffset
  result.deviceIndexCount = deviceIndexCount
  result.pDeviceIndices = pDeviceIndices

proc newVkWriteDescriptorSetAccelerationStructureKHR*(sType: VkStructureType, pNext: pointer = nil, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR): VkWriteDescriptorSetAccelerationStructureKHR =
  result.sType = sType
  result.pNext = pNext
  result.accelerationStructureCount = accelerationStructureCount
  result.pAccelerationStructures = pAccelerationStructures

proc newVkAccelerationStructureMemoryRequirementsInfoKHR*(sType: VkStructureType, pNext: pointer = nil, `type`: VkAccelerationStructureMemoryRequirementsTypeKHR, buildType: VkAccelerationStructureBuildTypeKHR, accelerationStructure: VkAccelerationStructureKHR): VkAccelerationStructureMemoryRequirementsInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.`type` = `type`
  result.buildType = buildType
  result.accelerationStructure = accelerationStructure

proc newVkAccelerationStructureMemoryRequirementsInfoNV*(sType: VkStructureType, pNext: pointer = nil, `type`: VkAccelerationStructureMemoryRequirementsTypeNV, accelerationStructure: VkAccelerationStructureNV): VkAccelerationStructureMemoryRequirementsInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.`type` = `type`
  result.accelerationStructure = accelerationStructure

proc newVkPhysicalDeviceRayTracingFeaturesKHR*(sType: VkStructureType, pNext: pointer = nil, rayTracing: VkBool32, rayTracingShaderGroupHandleCaptureReplay: VkBool32, rayTracingShaderGroupHandleCaptureReplayMixed: VkBool32, rayTracingAccelerationStructureCaptureReplay: VkBool32, rayTracingIndirectTraceRays: VkBool32, rayTracingIndirectAccelerationStructureBuild: VkBool32, rayTracingHostAccelerationStructureCommands: VkBool32, rayQuery: VkBool32, rayTracingPrimitiveCulling: VkBool32): VkPhysicalDeviceRayTracingFeaturesKHR =
  result.sType = sType
  result.pNext = pNext
  result.rayTracing = rayTracing
  result.rayTracingShaderGroupHandleCaptureReplay = rayTracingShaderGroupHandleCaptureReplay
  result.rayTracingShaderGroupHandleCaptureReplayMixed = rayTracingShaderGroupHandleCaptureReplayMixed
  result.rayTracingAccelerationStructureCaptureReplay = rayTracingAccelerationStructureCaptureReplay
  result.rayTracingIndirectTraceRays = rayTracingIndirectTraceRays
  result.rayTracingIndirectAccelerationStructureBuild = rayTracingIndirectAccelerationStructureBuild
  result.rayTracingHostAccelerationStructureCommands = rayTracingHostAccelerationStructureCommands
  result.rayQuery = rayQuery
  result.rayTracingPrimitiveCulling = rayTracingPrimitiveCulling

proc newVkPhysicalDeviceRayTracingPropertiesKHR*(sType: VkStructureType, pNext: pointer = nil, shaderGroupHandleSize: uint32, maxRecursionDepth: uint32, maxShaderGroupStride: uint32, shaderGroupBaseAlignment: uint32, maxGeometryCount: uint64, maxInstanceCount: uint64, maxPrimitiveCount: uint64, maxDescriptorSetAccelerationStructures: uint32, shaderGroupHandleCaptureReplaySize: uint32): VkPhysicalDeviceRayTracingPropertiesKHR =
  result.sType = sType
  result.pNext = pNext
  result.shaderGroupHandleSize = shaderGroupHandleSize
  result.maxRecursionDepth = maxRecursionDepth
  result.maxShaderGroupStride = maxShaderGroupStride
  result.shaderGroupBaseAlignment = shaderGroupBaseAlignment
  result.maxGeometryCount = maxGeometryCount
  result.maxInstanceCount = maxInstanceCount
  result.maxPrimitiveCount = maxPrimitiveCount
  result.maxDescriptorSetAccelerationStructures = maxDescriptorSetAccelerationStructures
  result.shaderGroupHandleCaptureReplaySize = shaderGroupHandleCaptureReplaySize

proc newVkPhysicalDeviceRayTracingPropertiesNV*(sType: VkStructureType, pNext: pointer = nil, shaderGroupHandleSize: uint32, maxRecursionDepth: uint32, maxShaderGroupStride: uint32, shaderGroupBaseAlignment: uint32, maxGeometryCount: uint64, maxInstanceCount: uint64, maxTriangleCount: uint64, maxDescriptorSetAccelerationStructures: uint32): VkPhysicalDeviceRayTracingPropertiesNV =
  result.sType = sType
  result.pNext = pNext
  result.shaderGroupHandleSize = shaderGroupHandleSize
  result.maxRecursionDepth = maxRecursionDepth
  result.maxShaderGroupStride = maxShaderGroupStride
  result.shaderGroupBaseAlignment = shaderGroupBaseAlignment
  result.maxGeometryCount = maxGeometryCount
  result.maxInstanceCount = maxInstanceCount
  result.maxTriangleCount = maxTriangleCount
  result.maxDescriptorSetAccelerationStructures = maxDescriptorSetAccelerationStructures

proc newVkStridedBufferRegionKHR*(buffer: VkBuffer, offset: VkDeviceSize, stride: VkDeviceSize, size: VkDeviceSize): VkStridedBufferRegionKHR =
  result.buffer = buffer
  result.offset = offset
  result.stride = stride
  result.size = size

proc newVkTraceRaysIndirectCommandKHR*(width: uint32, height: uint32, depth: uint32): VkTraceRaysIndirectCommandKHR =
  result.width = width
  result.height = height
  result.depth = depth

proc newVkDrmFormatModifierPropertiesListEXT*(sType: VkStructureType, pNext: pointer = nil, drmFormatModifierCount: uint32, pDrmFormatModifierProperties: ptr VkDrmFormatModifierPropertiesEXT): VkDrmFormatModifierPropertiesListEXT =
  result.sType = sType
  result.pNext = pNext
  result.drmFormatModifierCount = drmFormatModifierCount
  result.pDrmFormatModifierProperties = pDrmFormatModifierProperties

proc newVkDrmFormatModifierPropertiesEXT*(drmFormatModifier: uint64, drmFormatModifierPlaneCount: uint32, drmFormatModifierTilingFeatures: VkFormatFeatureFlags): VkDrmFormatModifierPropertiesEXT =
  result.drmFormatModifier = drmFormatModifier
  result.drmFormatModifierPlaneCount = drmFormatModifierPlaneCount
  result.drmFormatModifierTilingFeatures = drmFormatModifierTilingFeatures

proc newVkPhysicalDeviceImageDrmFormatModifierInfoEXT*(sType: VkStructureType, pNext: pointer = nil, drmFormatModifier: uint64, sharingMode: VkSharingMode, queueFamilyIndexCount: uint32, pQueueFamilyIndices: ptr uint32): VkPhysicalDeviceImageDrmFormatModifierInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.drmFormatModifier = drmFormatModifier
  result.sharingMode = sharingMode
  result.queueFamilyIndexCount = queueFamilyIndexCount
  result.pQueueFamilyIndices = pQueueFamilyIndices

proc newVkImageDrmFormatModifierListCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, drmFormatModifierCount: uint32, pDrmFormatModifiers: ptr uint64): VkImageDrmFormatModifierListCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.drmFormatModifierCount = drmFormatModifierCount
  result.pDrmFormatModifiers = pDrmFormatModifiers

proc newVkImageDrmFormatModifierExplicitCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, drmFormatModifier: uint64, drmFormatModifierPlaneCount: uint32, pPlaneLayouts: ptr VkSubresourceLayout): VkImageDrmFormatModifierExplicitCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.drmFormatModifier = drmFormatModifier
  result.drmFormatModifierPlaneCount = drmFormatModifierPlaneCount
  result.pPlaneLayouts = pPlaneLayouts

proc newVkImageDrmFormatModifierPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, drmFormatModifier: uint64): VkImageDrmFormatModifierPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.drmFormatModifier = drmFormatModifier

proc newVkImageStencilUsageCreateInfo*(sType: VkStructureType, pNext: pointer = nil, stencilUsage: VkImageUsageFlags): VkImageStencilUsageCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.stencilUsage = stencilUsage

proc newVkDeviceMemoryOverallocationCreateInfoAMD*(sType: VkStructureType, pNext: pointer = nil, overallocationBehavior: VkMemoryOverallocationBehaviorAMD): VkDeviceMemoryOverallocationCreateInfoAMD =
  result.sType = sType
  result.pNext = pNext
  result.overallocationBehavior = overallocationBehavior

proc newVkPhysicalDeviceFragmentDensityMapFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, fragmentDensityMap: VkBool32, fragmentDensityMapDynamic: VkBool32, fragmentDensityMapNonSubsampledImages: VkBool32): VkPhysicalDeviceFragmentDensityMapFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.fragmentDensityMap = fragmentDensityMap
  result.fragmentDensityMapDynamic = fragmentDensityMapDynamic
  result.fragmentDensityMapNonSubsampledImages = fragmentDensityMapNonSubsampledImages

proc newVkPhysicalDeviceFragmentDensityMap2FeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, fragmentDensityMapDeferred: VkBool32): VkPhysicalDeviceFragmentDensityMap2FeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.fragmentDensityMapDeferred = fragmentDensityMapDeferred

proc newVkPhysicalDeviceFragmentDensityMapPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, minFragmentDensityTexelSize: VkExtent2D, maxFragmentDensityTexelSize: VkExtent2D, fragmentDensityInvocations: VkBool32): VkPhysicalDeviceFragmentDensityMapPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.minFragmentDensityTexelSize = minFragmentDensityTexelSize
  result.maxFragmentDensityTexelSize = maxFragmentDensityTexelSize
  result.fragmentDensityInvocations = fragmentDensityInvocations

proc newVkPhysicalDeviceFragmentDensityMap2PropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, subsampledLoads: VkBool32, subsampledCoarseReconstructionEarlyAccess: VkBool32, maxSubsampledArrayLayers: uint32, maxDescriptorSetSubsampledSamplers: uint32): VkPhysicalDeviceFragmentDensityMap2PropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.subsampledLoads = subsampledLoads
  result.subsampledCoarseReconstructionEarlyAccess = subsampledCoarseReconstructionEarlyAccess
  result.maxSubsampledArrayLayers = maxSubsampledArrayLayers
  result.maxDescriptorSetSubsampledSamplers = maxDescriptorSetSubsampledSamplers

proc newVkRenderPassFragmentDensityMapCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, fragmentDensityMapAttachment: VkAttachmentReference): VkRenderPassFragmentDensityMapCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.fragmentDensityMapAttachment = fragmentDensityMapAttachment

proc newVkPhysicalDeviceScalarBlockLayoutFeatures*(sType: VkStructureType, pNext: pointer = nil, scalarBlockLayout: VkBool32): VkPhysicalDeviceScalarBlockLayoutFeatures =
  result.sType = sType
  result.pNext = pNext
  result.scalarBlockLayout = scalarBlockLayout

proc newVkSurfaceProtectedCapabilitiesKHR*(sType: VkStructureType, pNext: pointer = nil, supportsProtected: VkBool32): VkSurfaceProtectedCapabilitiesKHR =
  result.sType = sType
  result.pNext = pNext
  result.supportsProtected = supportsProtected

proc newVkPhysicalDeviceUniformBufferStandardLayoutFeatures*(sType: VkStructureType, pNext: pointer = nil, uniformBufferStandardLayout: VkBool32): VkPhysicalDeviceUniformBufferStandardLayoutFeatures =
  result.sType = sType
  result.pNext = pNext
  result.uniformBufferStandardLayout = uniformBufferStandardLayout

proc newVkPhysicalDeviceDepthClipEnableFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, depthClipEnable: VkBool32): VkPhysicalDeviceDepthClipEnableFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.depthClipEnable = depthClipEnable

proc newVkPipelineRasterizationDepthClipStateCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineRasterizationDepthClipStateCreateFlagsEXT = 0.VkPipelineRasterizationDepthClipStateCreateFlagsEXT, depthClipEnable: VkBool32): VkPipelineRasterizationDepthClipStateCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.depthClipEnable = depthClipEnable

proc newVkPhysicalDeviceMemoryBudgetPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, heapBudget: array[VK_MAX_MEMORY_HEAPS, VkDeviceSize], heapUsage: array[VK_MAX_MEMORY_HEAPS, VkDeviceSize]): VkPhysicalDeviceMemoryBudgetPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.heapBudget = heapBudget
  result.heapUsage = heapUsage

proc newVkPhysicalDeviceMemoryPriorityFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, memoryPriority: VkBool32): VkPhysicalDeviceMemoryPriorityFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.memoryPriority = memoryPriority

proc newVkMemoryPriorityAllocateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, priority: float32): VkMemoryPriorityAllocateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.priority = priority

proc newVkPhysicalDeviceBufferDeviceAddressFeatures*(sType: VkStructureType, pNext: pointer = nil, bufferDeviceAddress: VkBool32, bufferDeviceAddressCaptureReplay: VkBool32, bufferDeviceAddressMultiDevice: VkBool32): VkPhysicalDeviceBufferDeviceAddressFeatures =
  result.sType = sType
  result.pNext = pNext
  result.bufferDeviceAddress = bufferDeviceAddress
  result.bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay
  result.bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice

proc newVkPhysicalDeviceBufferDeviceAddressFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, bufferDeviceAddress: VkBool32, bufferDeviceAddressCaptureReplay: VkBool32, bufferDeviceAddressMultiDevice: VkBool32): VkPhysicalDeviceBufferDeviceAddressFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.bufferDeviceAddress = bufferDeviceAddress
  result.bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay
  result.bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice

proc newVkBufferDeviceAddressInfo*(sType: VkStructureType, pNext: pointer = nil, buffer: VkBuffer): VkBufferDeviceAddressInfo =
  result.sType = sType
  result.pNext = pNext
  result.buffer = buffer

proc newVkBufferOpaqueCaptureAddressCreateInfo*(sType: VkStructureType, pNext: pointer = nil, opaqueCaptureAddress: uint64): VkBufferOpaqueCaptureAddressCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.opaqueCaptureAddress = opaqueCaptureAddress

proc newVkBufferDeviceAddressCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, deviceAddress: VkDeviceAddress): VkBufferDeviceAddressCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.deviceAddress = deviceAddress

proc newVkPhysicalDeviceImageViewImageFormatInfoEXT*(sType: VkStructureType, pNext: pointer = nil, imageViewType: VkImageViewType): VkPhysicalDeviceImageViewImageFormatInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.imageViewType = imageViewType

proc newVkFilterCubicImageViewImageFormatPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, filterCubic: VkBool32, filterCubicMinmax: VkBool32): VkFilterCubicImageViewImageFormatPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.filterCubic = filterCubic
  result.filterCubicMinmax = filterCubicMinmax

proc newVkPhysicalDeviceImagelessFramebufferFeatures*(sType: VkStructureType, pNext: pointer = nil, imagelessFramebuffer: VkBool32): VkPhysicalDeviceImagelessFramebufferFeatures =
  result.sType = sType
  result.pNext = pNext
  result.imagelessFramebuffer = imagelessFramebuffer

proc newVkFramebufferAttachmentsCreateInfo*(sType: VkStructureType, pNext: pointer = nil, attachmentImageInfoCount: uint32, pAttachmentImageInfos: ptr VkFramebufferAttachmentImageInfo): VkFramebufferAttachmentsCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.attachmentImageInfoCount = attachmentImageInfoCount
  result.pAttachmentImageInfos = pAttachmentImageInfos

proc newVkFramebufferAttachmentImageInfo*(sType: VkStructureType, pNext: pointer = nil, flags: VkImageCreateFlags = 0.VkImageCreateFlags, usage: VkImageUsageFlags, width: uint32, height: uint32, layerCount: uint32, viewFormatCount: uint32, pViewFormats: ptr VkFormat): VkFramebufferAttachmentImageInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.usage = usage
  result.width = width
  result.height = height
  result.layerCount = layerCount
  result.viewFormatCount = viewFormatCount
  result.pViewFormats = pViewFormats

proc newVkRenderPassAttachmentBeginInfo*(sType: VkStructureType, pNext: pointer = nil, attachmentCount: uint32, pAttachments: ptr VkImageView): VkRenderPassAttachmentBeginInfo =
  result.sType = sType
  result.pNext = pNext
  result.attachmentCount = attachmentCount
  result.pAttachments = pAttachments

proc newVkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, textureCompressionASTC_HDR: VkBool32): VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.textureCompressionASTC_HDR = textureCompressionASTC_HDR

proc newVkPhysicalDeviceCooperativeMatrixFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, cooperativeMatrix: VkBool32, cooperativeMatrixRobustBufferAccess: VkBool32): VkPhysicalDeviceCooperativeMatrixFeaturesNV =
  result.sType = sType
  result.pNext = pNext
  result.cooperativeMatrix = cooperativeMatrix
  result.cooperativeMatrixRobustBufferAccess = cooperativeMatrixRobustBufferAccess

proc newVkPhysicalDeviceCooperativeMatrixPropertiesNV*(sType: VkStructureType, pNext: pointer = nil, cooperativeMatrixSupportedStages: VkShaderStageFlags): VkPhysicalDeviceCooperativeMatrixPropertiesNV =
  result.sType = sType
  result.pNext = pNext
  result.cooperativeMatrixSupportedStages = cooperativeMatrixSupportedStages

proc newVkCooperativeMatrixPropertiesNV*(sType: VkStructureType, pNext: pointer = nil, MSize: uint32, NSize: uint32, KSize: uint32, AType: VkComponentTypeNV, BType: VkComponentTypeNV, CType: VkComponentTypeNV, DType: VkComponentTypeNV, scope: VkScopeNV): VkCooperativeMatrixPropertiesNV =
  result.sType = sType
  result.pNext = pNext
  result.MSize = MSize
  result.NSize = NSize
  result.KSize = KSize
  result.AType = AType
  result.BType = BType
  result.CType = CType
  result.DType = DType
  result.scope = scope

proc newVkPhysicalDeviceYcbcrImageArraysFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, ycbcrImageArrays: VkBool32): VkPhysicalDeviceYcbcrImageArraysFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.ycbcrImageArrays = ycbcrImageArrays

proc newVkImageViewHandleInfoNVX*(sType: VkStructureType, pNext: pointer = nil, imageView: VkImageView, descriptorType: VkDescriptorType, sampler: VkSampler): VkImageViewHandleInfoNVX =
  result.sType = sType
  result.pNext = pNext
  result.imageView = imageView
  result.descriptorType = descriptorType
  result.sampler = sampler

proc newVkImageViewAddressPropertiesNVX*(sType: VkStructureType, pNext: pointer = nil, deviceAddress: VkDeviceAddress, size: VkDeviceSize): VkImageViewAddressPropertiesNVX =
  result.sType = sType
  result.pNext = pNext
  result.deviceAddress = deviceAddress
  result.size = size

proc newVkPresentFrameTokenGGP*(sType: VkStructureType, pNext: pointer = nil, frameToken: GgpFrameToken): VkPresentFrameTokenGGP =
  result.sType = sType
  result.pNext = pNext
  result.frameToken = frameToken

proc newVkPipelineCreationFeedbackEXT*(flags: VkPipelineCreationFeedbackFlagsEXT = 0.VkPipelineCreationFeedbackFlagsEXT, duration: uint64): VkPipelineCreationFeedbackEXT =
  result.flags = flags
  result.duration = duration

proc newVkPipelineCreationFeedbackCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, pPipelineCreationFeedback: ptr VkPipelineCreationFeedbackEXT, pipelineStageCreationFeedbackCount: uint32, pPipelineStageCreationFeedbacks: ptr ptr VkPipelineCreationFeedbackEXT): VkPipelineCreationFeedbackCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.pPipelineCreationFeedback = pPipelineCreationFeedback
  result.pipelineStageCreationFeedbackCount = pipelineStageCreationFeedbackCount
  result.pPipelineStageCreationFeedbacks = pPipelineStageCreationFeedbacks

proc newVkSurfaceFullScreenExclusiveInfoEXT*(sType: VkStructureType, pNext: pointer = nil, fullScreenExclusive: VkFullScreenExclusiveEXT): VkSurfaceFullScreenExclusiveInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.fullScreenExclusive = fullScreenExclusive

proc newVkSurfaceFullScreenExclusiveWin32InfoEXT*(sType: VkStructureType, pNext: pointer = nil, hmonitor: HMONITOR): VkSurfaceFullScreenExclusiveWin32InfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.hmonitor = hmonitor

proc newVkSurfaceCapabilitiesFullScreenExclusiveEXT*(sType: VkStructureType, pNext: pointer = nil, fullScreenExclusiveSupported: VkBool32): VkSurfaceCapabilitiesFullScreenExclusiveEXT =
  result.sType = sType
  result.pNext = pNext
  result.fullScreenExclusiveSupported = fullScreenExclusiveSupported

proc newVkPhysicalDevicePerformanceQueryFeaturesKHR*(sType: VkStructureType, pNext: pointer = nil, performanceCounterQueryPools: VkBool32, performanceCounterMultipleQueryPools: VkBool32): VkPhysicalDevicePerformanceQueryFeaturesKHR =
  result.sType = sType
  result.pNext = pNext
  result.performanceCounterQueryPools = performanceCounterQueryPools
  result.performanceCounterMultipleQueryPools = performanceCounterMultipleQueryPools

proc newVkPhysicalDevicePerformanceQueryPropertiesKHR*(sType: VkStructureType, pNext: pointer = nil, allowCommandBufferQueryCopies: VkBool32): VkPhysicalDevicePerformanceQueryPropertiesKHR =
  result.sType = sType
  result.pNext = pNext
  result.allowCommandBufferQueryCopies = allowCommandBufferQueryCopies

proc newVkPerformanceCounterKHR*(sType: VkStructureType, pNext: pointer = nil, unit: VkPerformanceCounterUnitKHR, scope: VkPerformanceCounterScopeKHR, storage: VkPerformanceCounterStorageKHR, uuid: array[VK_UUID_SIZE, uint8]): VkPerformanceCounterKHR =
  result.sType = sType
  result.pNext = pNext
  result.unit = unit
  result.scope = scope
  result.storage = storage
  result.uuid = uuid

proc newVkPerformanceCounterDescriptionKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkPerformanceCounterDescriptionFlagsKHR = 0.VkPerformanceCounterDescriptionFlagsKHR, name: array[VK_MAX_DESCRIPTION_SIZE, char], category: array[VK_MAX_DESCRIPTION_SIZE, char], description: array[VK_MAX_DESCRIPTION_SIZE, char]): VkPerformanceCounterDescriptionKHR =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.name = name
  result.category = category
  result.description = description

proc newVkQueryPoolPerformanceCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, queueFamilyIndex: uint32, counterIndexCount: uint32, pCounterIndices: ptr uint32): VkQueryPoolPerformanceCreateInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.queueFamilyIndex = queueFamilyIndex
  result.counterIndexCount = counterIndexCount
  result.pCounterIndices = pCounterIndices

proc newVkAcquireProfilingLockInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkAcquireProfilingLockFlagsKHR = 0.VkAcquireProfilingLockFlagsKHR, timeout: uint64): VkAcquireProfilingLockInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.timeout = timeout

proc newVkPerformanceQuerySubmitInfoKHR*(sType: VkStructureType, pNext: pointer = nil, counterPassIndex: uint32): VkPerformanceQuerySubmitInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.counterPassIndex = counterPassIndex

proc newVkHeadlessSurfaceCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkHeadlessSurfaceCreateFlagsEXT = 0.VkHeadlessSurfaceCreateFlagsEXT): VkHeadlessSurfaceCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags

proc newVkPhysicalDeviceCoverageReductionModeFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, coverageReductionMode: VkBool32): VkPhysicalDeviceCoverageReductionModeFeaturesNV =
  result.sType = sType
  result.pNext = pNext
  result.coverageReductionMode = coverageReductionMode

proc newVkPipelineCoverageReductionStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineCoverageReductionStateCreateFlagsNV = 0.VkPipelineCoverageReductionStateCreateFlagsNV, coverageReductionMode: VkCoverageReductionModeNV): VkPipelineCoverageReductionStateCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.coverageReductionMode = coverageReductionMode

proc newVkFramebufferMixedSamplesCombinationNV*(sType: VkStructureType, pNext: pointer = nil, coverageReductionMode: VkCoverageReductionModeNV, rasterizationSamples: VkSampleCountFlagBits, depthStencilSamples: VkSampleCountFlags, colorSamples: VkSampleCountFlags): VkFramebufferMixedSamplesCombinationNV =
  result.sType = sType
  result.pNext = pNext
  result.coverageReductionMode = coverageReductionMode
  result.rasterizationSamples = rasterizationSamples
  result.depthStencilSamples = depthStencilSamples
  result.colorSamples = colorSamples

proc newVkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*(sType: VkStructureType, pNext: pointer = nil, shaderIntegerFunctions2: VkBool32): VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL =
  result.sType = sType
  result.pNext = pNext
  result.shaderIntegerFunctions2 = shaderIntegerFunctions2

proc newVkPerformanceValueINTEL*(`type`: VkPerformanceValueTypeINTEL, data: VkPerformanceValueDataINTEL): VkPerformanceValueINTEL =
  result.`type` = `type`
  result.data = data

proc newVkInitializePerformanceApiInfoINTEL*(sType: VkStructureType, pNext: pointer = nil, pUserData: pointer = nil): VkInitializePerformanceApiInfoINTEL =
  result.sType = sType
  result.pNext = pNext
  result.pUserData = pUserData

proc newVkQueryPoolPerformanceQueryCreateInfoINTEL*(sType: VkStructureType, pNext: pointer = nil, performanceCountersSampling: VkQueryPoolSamplingModeINTEL): VkQueryPoolPerformanceQueryCreateInfoINTEL =
  result.sType = sType
  result.pNext = pNext
  result.performanceCountersSampling = performanceCountersSampling

proc newVkPerformanceMarkerInfoINTEL*(sType: VkStructureType, pNext: pointer = nil, marker: uint64): VkPerformanceMarkerInfoINTEL =
  result.sType = sType
  result.pNext = pNext
  result.marker = marker

proc newVkPerformanceStreamMarkerInfoINTEL*(sType: VkStructureType, pNext: pointer = nil, marker: uint32): VkPerformanceStreamMarkerInfoINTEL =
  result.sType = sType
  result.pNext = pNext
  result.marker = marker

proc newVkPerformanceOverrideInfoINTEL*(sType: VkStructureType, pNext: pointer = nil, `type`: VkPerformanceOverrideTypeINTEL, enable: VkBool32, parameter: uint64): VkPerformanceOverrideInfoINTEL =
  result.sType = sType
  result.pNext = pNext
  result.`type` = `type`
  result.enable = enable
  result.parameter = parameter

proc newVkPerformanceConfigurationAcquireInfoINTEL*(sType: VkStructureType, pNext: pointer = nil, `type`: VkPerformanceConfigurationTypeINTEL): VkPerformanceConfigurationAcquireInfoINTEL =
  result.sType = sType
  result.pNext = pNext
  result.`type` = `type`

proc newVkPhysicalDeviceShaderClockFeaturesKHR*(sType: VkStructureType, pNext: pointer = nil, shaderSubgroupClock: VkBool32, shaderDeviceClock: VkBool32): VkPhysicalDeviceShaderClockFeaturesKHR =
  result.sType = sType
  result.pNext = pNext
  result.shaderSubgroupClock = shaderSubgroupClock
  result.shaderDeviceClock = shaderDeviceClock

proc newVkPhysicalDeviceIndexTypeUint8FeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, indexTypeUint8: VkBool32): VkPhysicalDeviceIndexTypeUint8FeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.indexTypeUint8 = indexTypeUint8

proc newVkPhysicalDeviceShaderSMBuiltinsPropertiesNV*(sType: VkStructureType, pNext: pointer = nil, shaderSMCount: uint32, shaderWarpsPerSM: uint32): VkPhysicalDeviceShaderSMBuiltinsPropertiesNV =
  result.sType = sType
  result.pNext = pNext
  result.shaderSMCount = shaderSMCount
  result.shaderWarpsPerSM = shaderWarpsPerSM

proc newVkPhysicalDeviceShaderSMBuiltinsFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, shaderSMBuiltins: VkBool32): VkPhysicalDeviceShaderSMBuiltinsFeaturesNV =
  result.sType = sType
  result.pNext = pNext
  result.shaderSMBuiltins = shaderSMBuiltins

proc newVkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, fragmentShaderSampleInterlock: VkBool32, fragmentShaderPixelInterlock: VkBool32, fragmentShaderShadingRateInterlock: VkBool32): VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.fragmentShaderSampleInterlock = fragmentShaderSampleInterlock
  result.fragmentShaderPixelInterlock = fragmentShaderPixelInterlock
  result.fragmentShaderShadingRateInterlock = fragmentShaderShadingRateInterlock

proc newVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*(sType: VkStructureType, pNext: pointer = nil, separateDepthStencilLayouts: VkBool32): VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures =
  result.sType = sType
  result.pNext = pNext
  result.separateDepthStencilLayouts = separateDepthStencilLayouts

proc newVkAttachmentReferenceStencilLayout*(sType: VkStructureType, pNext: pointer = nil, stencilLayout: VkImageLayout): VkAttachmentReferenceStencilLayout =
  result.sType = sType
  result.pNext = pNext
  result.stencilLayout = stencilLayout

proc newVkAttachmentDescriptionStencilLayout*(sType: VkStructureType, pNext: pointer = nil, stencilInitialLayout: VkImageLayout, stencilFinalLayout: VkImageLayout): VkAttachmentDescriptionStencilLayout =
  result.sType = sType
  result.pNext = pNext
  result.stencilInitialLayout = stencilInitialLayout
  result.stencilFinalLayout = stencilFinalLayout

proc newVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*(sType: VkStructureType, pNext: pointer = nil, pipelineExecutableInfo: VkBool32): VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR =
  result.sType = sType
  result.pNext = pNext
  result.pipelineExecutableInfo = pipelineExecutableInfo

proc newVkPipelineInfoKHR*(sType: VkStructureType, pNext: pointer = nil, pipeline: VkPipeline): VkPipelineInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.pipeline = pipeline

proc newVkPipelineExecutablePropertiesKHR*(sType: VkStructureType, pNext: pointer = nil, stages: VkShaderStageFlags, name: array[VK_MAX_DESCRIPTION_SIZE, char], description: array[VK_MAX_DESCRIPTION_SIZE, char], subgroupSize: uint32): VkPipelineExecutablePropertiesKHR =
  result.sType = sType
  result.pNext = pNext
  result.stages = stages
  result.name = name
  result.description = description
  result.subgroupSize = subgroupSize

proc newVkPipelineExecutableInfoKHR*(sType: VkStructureType, pNext: pointer = nil, pipeline: VkPipeline, executableIndex: uint32): VkPipelineExecutableInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.pipeline = pipeline
  result.executableIndex = executableIndex

proc newVkPipelineExecutableStatisticKHR*(sType: VkStructureType, pNext: pointer = nil, name: array[VK_MAX_DESCRIPTION_SIZE, char], description: array[VK_MAX_DESCRIPTION_SIZE, char], format: VkPipelineExecutableStatisticFormatKHR, value: VkPipelineExecutableStatisticValueKHR): VkPipelineExecutableStatisticKHR =
  result.sType = sType
  result.pNext = pNext
  result.name = name
  result.description = description
  result.format = format
  result.value = value

proc newVkPipelineExecutableInternalRepresentationKHR*(sType: VkStructureType, pNext: pointer = nil, name: array[VK_MAX_DESCRIPTION_SIZE, char], description: array[VK_MAX_DESCRIPTION_SIZE, char], isText: VkBool32, dataSize: uint, pData: pointer = nil): VkPipelineExecutableInternalRepresentationKHR =
  result.sType = sType
  result.pNext = pNext
  result.name = name
  result.description = description
  result.isText = isText
  result.dataSize = dataSize
  result.pData = pData

proc newVkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, shaderDemoteToHelperInvocation: VkBool32): VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.shaderDemoteToHelperInvocation = shaderDemoteToHelperInvocation

proc newVkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, texelBufferAlignment: VkBool32): VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.texelBufferAlignment = texelBufferAlignment

proc newVkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, storageTexelBufferOffsetAlignmentBytes: VkDeviceSize, storageTexelBufferOffsetSingleTexelAlignment: VkBool32, uniformTexelBufferOffsetAlignmentBytes: VkDeviceSize, uniformTexelBufferOffsetSingleTexelAlignment: VkBool32): VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.storageTexelBufferOffsetAlignmentBytes = storageTexelBufferOffsetAlignmentBytes
  result.storageTexelBufferOffsetSingleTexelAlignment = storageTexelBufferOffsetSingleTexelAlignment
  result.uniformTexelBufferOffsetAlignmentBytes = uniformTexelBufferOffsetAlignmentBytes
  result.uniformTexelBufferOffsetSingleTexelAlignment = uniformTexelBufferOffsetSingleTexelAlignment

proc newVkPhysicalDeviceSubgroupSizeControlFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, subgroupSizeControl: VkBool32, computeFullSubgroups: VkBool32): VkPhysicalDeviceSubgroupSizeControlFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.subgroupSizeControl = subgroupSizeControl
  result.computeFullSubgroups = computeFullSubgroups

proc newVkPhysicalDeviceSubgroupSizeControlPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, minSubgroupSize: uint32, maxSubgroupSize: uint32, maxComputeWorkgroupSubgroups: uint32, requiredSubgroupSizeStages: VkShaderStageFlags): VkPhysicalDeviceSubgroupSizeControlPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.minSubgroupSize = minSubgroupSize
  result.maxSubgroupSize = maxSubgroupSize
  result.maxComputeWorkgroupSubgroups = maxComputeWorkgroupSubgroups
  result.requiredSubgroupSizeStages = requiredSubgroupSizeStages

proc newVkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, requiredSubgroupSize: uint32): VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.requiredSubgroupSize = requiredSubgroupSize

proc newVkMemoryOpaqueCaptureAddressAllocateInfo*(sType: VkStructureType, pNext: pointer = nil, opaqueCaptureAddress: uint64): VkMemoryOpaqueCaptureAddressAllocateInfo =
  result.sType = sType
  result.pNext = pNext
  result.opaqueCaptureAddress = opaqueCaptureAddress

proc newVkDeviceMemoryOpaqueCaptureAddressInfo*(sType: VkStructureType, pNext: pointer = nil, memory: VkDeviceMemory): VkDeviceMemoryOpaqueCaptureAddressInfo =
  result.sType = sType
  result.pNext = pNext
  result.memory = memory

proc newVkPhysicalDeviceLineRasterizationFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, rectangularLines: VkBool32, bresenhamLines: VkBool32, smoothLines: VkBool32, stippledRectangularLines: VkBool32, stippledBresenhamLines: VkBool32, stippledSmoothLines: VkBool32): VkPhysicalDeviceLineRasterizationFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.rectangularLines = rectangularLines
  result.bresenhamLines = bresenhamLines
  result.smoothLines = smoothLines
  result.stippledRectangularLines = stippledRectangularLines
  result.stippledBresenhamLines = stippledBresenhamLines
  result.stippledSmoothLines = stippledSmoothLines

proc newVkPhysicalDeviceLineRasterizationPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, lineSubPixelPrecisionBits: uint32): VkPhysicalDeviceLineRasterizationPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.lineSubPixelPrecisionBits = lineSubPixelPrecisionBits

proc newVkPipelineRasterizationLineStateCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, lineRasterizationMode: VkLineRasterizationModeEXT, stippledLineEnable: VkBool32, lineStippleFactor: uint32, lineStipplePattern: uint16): VkPipelineRasterizationLineStateCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.lineRasterizationMode = lineRasterizationMode
  result.stippledLineEnable = stippledLineEnable
  result.lineStippleFactor = lineStippleFactor
  result.lineStipplePattern = lineStipplePattern

proc newVkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, pipelineCreationCacheControl: VkBool32): VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.pipelineCreationCacheControl = pipelineCreationCacheControl

proc newVkPhysicalDeviceVulkan11Features*(sType: VkStructureType, pNext: pointer = nil, storageBuffer16BitAccess: VkBool32, uniformAndStorageBuffer16BitAccess: VkBool32, storagePushConstant16: VkBool32, storageInputOutput16: VkBool32, multiview: VkBool32, multiviewGeometryShader: VkBool32, multiviewTessellationShader: VkBool32, variablePointersStorageBuffer: VkBool32, variablePointers: VkBool32, protectedMemory: VkBool32, samplerYcbcrConversion: VkBool32, shaderDrawParameters: VkBool32): VkPhysicalDeviceVulkan11Features =
  result.sType = sType
  result.pNext = pNext
  result.storageBuffer16BitAccess = storageBuffer16BitAccess
  result.uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess
  result.storagePushConstant16 = storagePushConstant16
  result.storageInputOutput16 = storageInputOutput16
  result.multiview = multiview
  result.multiviewGeometryShader = multiviewGeometryShader
  result.multiviewTessellationShader = multiviewTessellationShader
  result.variablePointersStorageBuffer = variablePointersStorageBuffer
  result.variablePointers = variablePointers
  result.protectedMemory = protectedMemory
  result.samplerYcbcrConversion = samplerYcbcrConversion
  result.shaderDrawParameters = shaderDrawParameters

proc newVkPhysicalDeviceVulkan11Properties*(sType: VkStructureType, pNext: pointer = nil, deviceUUID: array[VK_UUID_SIZE, uint8], driverUUID: array[VK_UUID_SIZE, uint8], deviceLUID: array[VK_LUID_SIZE, uint8], deviceNodeMask: uint32, deviceLUIDValid: VkBool32, subgroupSize: uint32, subgroupSupportedStages: VkShaderStageFlags, subgroupSupportedOperations: VkSubgroupFeatureFlags, subgroupQuadOperationsInAllStages: VkBool32, pointClippingBehavior: VkPointClippingBehavior, maxMultiviewViewCount: uint32, maxMultiviewInstanceIndex: uint32, protectedNoFault: VkBool32, maxPerSetDescriptors: uint32, maxMemoryAllocationSize: VkDeviceSize): VkPhysicalDeviceVulkan11Properties =
  result.sType = sType
  result.pNext = pNext
  result.deviceUUID = deviceUUID
  result.driverUUID = driverUUID
  result.deviceLUID = deviceLUID
  result.deviceNodeMask = deviceNodeMask
  result.deviceLUIDValid = deviceLUIDValid
  result.subgroupSize = subgroupSize
  result.subgroupSupportedStages = subgroupSupportedStages
  result.subgroupSupportedOperations = subgroupSupportedOperations
  result.subgroupQuadOperationsInAllStages = subgroupQuadOperationsInAllStages
  result.pointClippingBehavior = pointClippingBehavior
  result.maxMultiviewViewCount = maxMultiviewViewCount
  result.maxMultiviewInstanceIndex = maxMultiviewInstanceIndex
  result.protectedNoFault = protectedNoFault
  result.maxPerSetDescriptors = maxPerSetDescriptors
  result.maxMemoryAllocationSize = maxMemoryAllocationSize

proc newVkPhysicalDeviceVulkan12Features*(sType: VkStructureType, pNext: pointer = nil, samplerMirrorClampToEdge: VkBool32, drawIndirectCount: VkBool32, storageBuffer8BitAccess: VkBool32, uniformAndStorageBuffer8BitAccess: VkBool32, storagePushConstant8: VkBool32, shaderBufferInt64Atomics: VkBool32, shaderSharedInt64Atomics: VkBool32, shaderFloat16: VkBool32, shaderInt8: VkBool32, descriptorIndexing: 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: VkBool32, samplerFilterMinmax: VkBool32, scalarBlockLayout: VkBool32, imagelessFramebuffer: VkBool32, uniformBufferStandardLayout: VkBool32, shaderSubgroupExtendedTypes: VkBool32, separateDepthStencilLayouts: VkBool32, hostQueryReset: VkBool32, timelineSemaphore: VkBool32, bufferDeviceAddress: VkBool32, bufferDeviceAddressCaptureReplay: VkBool32, bufferDeviceAddressMultiDevice: VkBool32, vulkanMemoryModel: VkBool32, vulkanMemoryModelDeviceScope: VkBool32, vulkanMemoryModelAvailabilityVisibilityChains: VkBool32, shaderOutputViewportIndex: VkBool32, shaderOutputLayer: VkBool32, subgroupBroadcastDynamicId: VkBool32): VkPhysicalDeviceVulkan12Features =
  result.sType = sType
  result.pNext = pNext
  result.samplerMirrorClampToEdge = samplerMirrorClampToEdge
  result.drawIndirectCount = drawIndirectCount
  result.storageBuffer8BitAccess = storageBuffer8BitAccess
  result.uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess
  result.storagePushConstant8 = storagePushConstant8
  result.shaderBufferInt64Atomics = shaderBufferInt64Atomics
  result.shaderSharedInt64Atomics = shaderSharedInt64Atomics
  result.shaderFloat16 = shaderFloat16
  result.shaderInt8 = shaderInt8
  result.descriptorIndexing = descriptorIndexing
  result.shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing
  result.shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing
  result.shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing
  result.shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing
  result.shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing
  result.shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing
  result.shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing
  result.shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing
  result.shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing
  result.shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing
  result.descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind
  result.descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind
  result.descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind
  result.descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind
  result.descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind
  result.descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind
  result.descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending
  result.descriptorBindingPartiallyBound = descriptorBindingPartiallyBound
  result.descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount
  result.runtimeDescriptorArray = runtimeDescriptorArray
  result.samplerFilterMinmax = samplerFilterMinmax
  result.scalarBlockLayout = scalarBlockLayout
  result.imagelessFramebuffer = imagelessFramebuffer
  result.uniformBufferStandardLayout = uniformBufferStandardLayout
  result.shaderSubgroupExtendedTypes = shaderSubgroupExtendedTypes
  result.separateDepthStencilLayouts = separateDepthStencilLayouts
  result.hostQueryReset = hostQueryReset
  result.timelineSemaphore = timelineSemaphore
  result.bufferDeviceAddress = bufferDeviceAddress
  result.bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay
  result.bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice
  result.vulkanMemoryModel = vulkanMemoryModel
  result.vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope
  result.vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains
  result.shaderOutputViewportIndex = shaderOutputViewportIndex
  result.shaderOutputLayer = shaderOutputLayer
  result.subgroupBroadcastDynamicId = subgroupBroadcastDynamicId

proc newVkPhysicalDeviceVulkan12Properties*(sType: VkStructureType, pNext: pointer = nil, driverID: VkDriverId, driverName: array[VK_MAX_DRIVER_NAME_SIZE, char], driverInfo: array[VK_MAX_DRIVER_INFO_SIZE, char], conformanceVersion: VkConformanceVersion, denormBehaviorIndependence: VkShaderFloatControlsIndependence, roundingModeIndependence: VkShaderFloatControlsIndependence, shaderSignedZeroInfNanPreserveFloat16: VkBool32, shaderSignedZeroInfNanPreserveFloat32: VkBool32, shaderSignedZeroInfNanPreserveFloat64: VkBool32, shaderDenormPreserveFloat16: VkBool32, shaderDenormPreserveFloat32: VkBool32, shaderDenormPreserveFloat64: VkBool32, shaderDenormFlushToZeroFloat16: VkBool32, shaderDenormFlushToZeroFloat32: VkBool32, shaderDenormFlushToZeroFloat64: VkBool32, shaderRoundingModeRTEFloat16: VkBool32, shaderRoundingModeRTEFloat32: VkBool32, shaderRoundingModeRTEFloat64: VkBool32, shaderRoundingModeRTZFloat16: VkBool32, shaderRoundingModeRTZFloat32: VkBool32, shaderRoundingModeRTZFloat64: VkBool32, maxUpdateAfterBindDescriptorsInAllPools: uint32, shaderUniformBufferArrayNonUniformIndexingNative: VkBool32, shaderSampledImageArrayNonUniformIndexingNative: VkBool32, shaderStorageBufferArrayNonUniformIndexingNative: VkBool32, shaderStorageImageArrayNonUniformIndexingNative: VkBool32, shaderInputAttachmentArrayNonUniformIndexingNative: VkBool32, robustBufferAccessUpdateAfterBind: VkBool32, quadDivergentImplicitLod: VkBool32, maxPerStageDescriptorUpdateAfterBindSamplers: uint32, maxPerStageDescriptorUpdateAfterBindUniformBuffers: uint32, maxPerStageDescriptorUpdateAfterBindStorageBuffers: uint32, maxPerStageDescriptorUpdateAfterBindSampledImages: uint32, maxPerStageDescriptorUpdateAfterBindStorageImages: uint32, maxPerStageDescriptorUpdateAfterBindInputAttachments: uint32, maxPerStageUpdateAfterBindResources: uint32, maxDescriptorSetUpdateAfterBindSamplers: uint32, maxDescriptorSetUpdateAfterBindUniformBuffers: uint32, maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: uint32, maxDescriptorSetUpdateAfterBindStorageBuffers: uint32, maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: uint32, maxDescriptorSetUpdateAfterBindSampledImages: uint32, maxDescriptorSetUpdateAfterBindStorageImages: uint32, maxDescriptorSetUpdateAfterBindInputAttachments: uint32, supportedDepthResolveModes: VkResolveModeFlags, supportedStencilResolveModes: VkResolveModeFlags, independentResolveNone: VkBool32, independentResolve: VkBool32, filterMinmaxSingleComponentFormats: VkBool32, filterMinmaxImageComponentMapping: VkBool32, maxTimelineSemaphoreValueDifference: uint64, framebufferIntegerColorSampleCounts: VkSampleCountFlags): VkPhysicalDeviceVulkan12Properties =
  result.sType = sType
  result.pNext = pNext
  result.driverID = driverID
  result.driverName = driverName
  result.driverInfo = driverInfo
  result.conformanceVersion = conformanceVersion
  result.denormBehaviorIndependence = denormBehaviorIndependence
  result.roundingModeIndependence = roundingModeIndependence
  result.shaderSignedZeroInfNanPreserveFloat16 = shaderSignedZeroInfNanPreserveFloat16
  result.shaderSignedZeroInfNanPreserveFloat32 = shaderSignedZeroInfNanPreserveFloat32
  result.shaderSignedZeroInfNanPreserveFloat64 = shaderSignedZeroInfNanPreserveFloat64
  result.shaderDenormPreserveFloat16 = shaderDenormPreserveFloat16
  result.shaderDenormPreserveFloat32 = shaderDenormPreserveFloat32
  result.shaderDenormPreserveFloat64 = shaderDenormPreserveFloat64
  result.shaderDenormFlushToZeroFloat16 = shaderDenormFlushToZeroFloat16
  result.shaderDenormFlushToZeroFloat32 = shaderDenormFlushToZeroFloat32
  result.shaderDenormFlushToZeroFloat64 = shaderDenormFlushToZeroFloat64
  result.shaderRoundingModeRTEFloat16 = shaderRoundingModeRTEFloat16
  result.shaderRoundingModeRTEFloat32 = shaderRoundingModeRTEFloat32
  result.shaderRoundingModeRTEFloat64 = shaderRoundingModeRTEFloat64
  result.shaderRoundingModeRTZFloat16 = shaderRoundingModeRTZFloat16
  result.shaderRoundingModeRTZFloat32 = shaderRoundingModeRTZFloat32
  result.shaderRoundingModeRTZFloat64 = shaderRoundingModeRTZFloat64
  result.maxUpdateAfterBindDescriptorsInAllPools = maxUpdateAfterBindDescriptorsInAllPools
  result.shaderUniformBufferArrayNonUniformIndexingNative = shaderUniformBufferArrayNonUniformIndexingNative
  result.shaderSampledImageArrayNonUniformIndexingNative = shaderSampledImageArrayNonUniformIndexingNative
  result.shaderStorageBufferArrayNonUniformIndexingNative = shaderStorageBufferArrayNonUniformIndexingNative
  result.shaderStorageImageArrayNonUniformIndexingNative = shaderStorageImageArrayNonUniformIndexingNative
  result.shaderInputAttachmentArrayNonUniformIndexingNative = shaderInputAttachmentArrayNonUniformIndexingNative
  result.robustBufferAccessUpdateAfterBind = robustBufferAccessUpdateAfterBind
  result.quadDivergentImplicitLod = quadDivergentImplicitLod
  result.maxPerStageDescriptorUpdateAfterBindSamplers = maxPerStageDescriptorUpdateAfterBindSamplers
  result.maxPerStageDescriptorUpdateAfterBindUniformBuffers = maxPerStageDescriptorUpdateAfterBindUniformBuffers
  result.maxPerStageDescriptorUpdateAfterBindStorageBuffers = maxPerStageDescriptorUpdateAfterBindStorageBuffers
  result.maxPerStageDescriptorUpdateAfterBindSampledImages = maxPerStageDescriptorUpdateAfterBindSampledImages
  result.maxPerStageDescriptorUpdateAfterBindStorageImages = maxPerStageDescriptorUpdateAfterBindStorageImages
  result.maxPerStageDescriptorUpdateAfterBindInputAttachments = maxPerStageDescriptorUpdateAfterBindInputAttachments
  result.maxPerStageUpdateAfterBindResources = maxPerStageUpdateAfterBindResources
  result.maxDescriptorSetUpdateAfterBindSamplers = maxDescriptorSetUpdateAfterBindSamplers
  result.maxDescriptorSetUpdateAfterBindUniformBuffers = maxDescriptorSetUpdateAfterBindUniformBuffers
  result.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = maxDescriptorSetUpdateAfterBindUniformBuffersDynamic
  result.maxDescriptorSetUpdateAfterBindStorageBuffers = maxDescriptorSetUpdateAfterBindStorageBuffers
  result.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = maxDescriptorSetUpdateAfterBindStorageBuffersDynamic
  result.maxDescriptorSetUpdateAfterBindSampledImages = maxDescriptorSetUpdateAfterBindSampledImages
  result.maxDescriptorSetUpdateAfterBindStorageImages = maxDescriptorSetUpdateAfterBindStorageImages
  result.maxDescriptorSetUpdateAfterBindInputAttachments = maxDescriptorSetUpdateAfterBindInputAttachments
  result.supportedDepthResolveModes = supportedDepthResolveModes
  result.supportedStencilResolveModes = supportedStencilResolveModes
  result.independentResolveNone = independentResolveNone
  result.independentResolve = independentResolve
  result.filterMinmaxSingleComponentFormats = filterMinmaxSingleComponentFormats
  result.filterMinmaxImageComponentMapping = filterMinmaxImageComponentMapping
  result.maxTimelineSemaphoreValueDifference = maxTimelineSemaphoreValueDifference
  result.framebufferIntegerColorSampleCounts = framebufferIntegerColorSampleCounts

proc newVkPipelineCompilerControlCreateInfoAMD*(sType: VkStructureType, pNext: pointer = nil, compilerControlFlags: VkPipelineCompilerControlFlagsAMD): VkPipelineCompilerControlCreateInfoAMD =
  result.sType = sType
  result.pNext = pNext
  result.compilerControlFlags = compilerControlFlags

proc newVkPhysicalDeviceCoherentMemoryFeaturesAMD*(sType: VkStructureType, pNext: pointer = nil, deviceCoherentMemory: VkBool32): VkPhysicalDeviceCoherentMemoryFeaturesAMD =
  result.sType = sType
  result.pNext = pNext
  result.deviceCoherentMemory = deviceCoherentMemory

proc newVkPhysicalDeviceToolPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, name: array[VK_MAX_EXTENSION_NAME_SIZE, char], version: array[VK_MAX_EXTENSION_NAME_SIZE, char], purposes: VkToolPurposeFlagsEXT, description: array[VK_MAX_DESCRIPTION_SIZE, char], layer: array[VK_MAX_EXTENSION_NAME_SIZE, char]): VkPhysicalDeviceToolPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.name = name
  result.version = version
  result.purposes = purposes
  result.description = description
  result.layer = layer

proc newVkSamplerCustomBorderColorCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, customBorderColor: VkClearColorValue, format: VkFormat): VkSamplerCustomBorderColorCreateInfoEXT =
  result.sType = sType
  result.pNext = pNext
  result.customBorderColor = customBorderColor
  result.format = format

proc newVkPhysicalDeviceCustomBorderColorPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, maxCustomBorderColorSamplers: uint32): VkPhysicalDeviceCustomBorderColorPropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.maxCustomBorderColorSamplers = maxCustomBorderColorSamplers

proc newVkPhysicalDeviceCustomBorderColorFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, customBorderColors: VkBool32, customBorderColorWithoutFormat: VkBool32): VkPhysicalDeviceCustomBorderColorFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.customBorderColors = customBorderColors
  result.customBorderColorWithoutFormat = customBorderColorWithoutFormat

proc newVkAccelerationStructureGeometryTrianglesDataKHR*(sType: VkStructureType, pNext: pointer = nil, vertexFormat: VkFormat, vertexData: VkDeviceOrHostAddressConstKHR, vertexStride: VkDeviceSize, indexType: VkIndexType, indexData: VkDeviceOrHostAddressConstKHR, transformData: VkDeviceOrHostAddressConstKHR): VkAccelerationStructureGeometryTrianglesDataKHR =
  result.sType = sType
  result.pNext = pNext
  result.vertexFormat = vertexFormat
  result.vertexData = vertexData
  result.vertexStride = vertexStride
  result.indexType = indexType
  result.indexData = indexData
  result.transformData = transformData

proc newVkAccelerationStructureGeometryAabbsDataKHR*(sType: VkStructureType, pNext: pointer = nil, data: VkDeviceOrHostAddressConstKHR, stride: VkDeviceSize): VkAccelerationStructureGeometryAabbsDataKHR =
  result.sType = sType
  result.pNext = pNext
  result.data = data
  result.stride = stride

proc newVkAccelerationStructureGeometryInstancesDataKHR*(sType: VkStructureType, pNext: pointer = nil, arrayOfPointers: VkBool32, data: VkDeviceOrHostAddressConstKHR): VkAccelerationStructureGeometryInstancesDataKHR =
  result.sType = sType
  result.pNext = pNext
  result.arrayOfPointers = arrayOfPointers
  result.data = data

proc newVkAccelerationStructureGeometryKHR*(sType: VkStructureType, pNext: pointer = nil, geometryType: VkGeometryTypeKHR, geometry: VkAccelerationStructureGeometryDataKHR, flags: VkGeometryFlagsKHR = 0.VkGeometryFlagsKHR): VkAccelerationStructureGeometryKHR =
  result.sType = sType
  result.pNext = pNext
  result.geometryType = geometryType
  result.geometry = geometry
  result.flags = flags

proc newVkAccelerationStructureBuildGeometryInfoKHR*(sType: VkStructureType, pNext: pointer = nil, `type`: VkAccelerationStructureTypeKHR, flags: VkBuildAccelerationStructureFlagsKHR = 0.VkBuildAccelerationStructureFlagsKHR, update: VkBool32, srcAccelerationStructure: VkAccelerationStructureKHR, dstAccelerationStructure: VkAccelerationStructureKHR, geometryArrayOfPointers: VkBool32, geometryCount: uint32, ppGeometries: ptr ptr VkAccelerationStructureGeometryKHR, scratchData: VkDeviceOrHostAddressKHR): VkAccelerationStructureBuildGeometryInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.`type` = `type`
  result.flags = flags
  result.update = update
  result.srcAccelerationStructure = srcAccelerationStructure
  result.dstAccelerationStructure = dstAccelerationStructure
  result.geometryArrayOfPointers = geometryArrayOfPointers
  result.geometryCount = geometryCount
  result.ppGeometries = ppGeometries
  result.scratchData = scratchData

proc newVkAccelerationStructureBuildOffsetInfoKHR*(primitiveCount: uint32, primitiveOffset: uint32, firstVertex: uint32, transformOffset: uint32): VkAccelerationStructureBuildOffsetInfoKHR =
  result.primitiveCount = primitiveCount
  result.primitiveOffset = primitiveOffset
  result.firstVertex = firstVertex
  result.transformOffset = transformOffset

proc newVkAccelerationStructureCreateGeometryTypeInfoKHR*(sType: VkStructureType, pNext: pointer = nil, geometryType: VkGeometryTypeKHR, maxPrimitiveCount: uint32, indexType: VkIndexType, maxVertexCount: uint32, vertexFormat: VkFormat, allowsTransforms: VkBool32): VkAccelerationStructureCreateGeometryTypeInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.geometryType = geometryType
  result.maxPrimitiveCount = maxPrimitiveCount
  result.indexType = indexType
  result.maxVertexCount = maxVertexCount
  result.vertexFormat = vertexFormat
  result.allowsTransforms = allowsTransforms

proc newVkAccelerationStructureCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, compactedSize: VkDeviceSize, `type`: VkAccelerationStructureTypeKHR, flags: VkBuildAccelerationStructureFlagsKHR = 0.VkBuildAccelerationStructureFlagsKHR, maxGeometryCount: uint32, pGeometryInfos: ptr VkAccelerationStructureCreateGeometryTypeInfoKHR, deviceAddress: VkDeviceAddress): VkAccelerationStructureCreateInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.compactedSize = compactedSize
  result.`type` = `type`
  result.flags = flags
  result.maxGeometryCount = maxGeometryCount
  result.pGeometryInfos = pGeometryInfos
  result.deviceAddress = deviceAddress

proc newVkAabbPositionsKHR*(minX: float32, minY: float32, minZ: float32, maxX: float32, maxY: float32, maxZ: float32): VkAabbPositionsKHR =
  result.minX = minX
  result.minY = minY
  result.minZ = minZ
  result.maxX = maxX
  result.maxY = maxY
  result.maxZ = maxZ

proc newVkTransformMatrixKHR*(matrix: array[3, float32]): VkTransformMatrixKHR =
  result.matrix = matrix

proc newVkAccelerationStructureInstanceKHR*(transform: VkTransformMatrixKHR, instanceCustomIndex: uint32, mask: uint32, instanceShaderBindingTableRecordOffset: uint32, flags: VkGeometryInstanceFlagsKHR = 0.VkGeometryInstanceFlagsKHR, accelerationStructureReference: uint64): VkAccelerationStructureInstanceKHR =
  result.transform = transform
  result.instanceCustomIndex = instanceCustomIndex
  result.mask = mask
  result.instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset
  result.flags = flags
  result.accelerationStructureReference = accelerationStructureReference

proc newVkAccelerationStructureDeviceAddressInfoKHR*(sType: VkStructureType, pNext: pointer = nil, accelerationStructure: VkAccelerationStructureKHR): VkAccelerationStructureDeviceAddressInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.accelerationStructure = accelerationStructure

proc newVkAccelerationStructureVersionKHR*(sType: VkStructureType, pNext: pointer = nil, versionData: ptr uint8): VkAccelerationStructureVersionKHR =
  result.sType = sType
  result.pNext = pNext
  result.versionData = versionData

proc newVkCopyAccelerationStructureInfoKHR*(sType: VkStructureType, pNext: pointer = nil, src: VkAccelerationStructureKHR, dst: VkAccelerationStructureKHR, mode: VkCopyAccelerationStructureModeKHR): VkCopyAccelerationStructureInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.src = src
  result.dst = dst
  result.mode = mode

proc newVkCopyAccelerationStructureToMemoryInfoKHR*(sType: VkStructureType, pNext: pointer = nil, src: VkAccelerationStructureKHR, dst: VkDeviceOrHostAddressKHR, mode: VkCopyAccelerationStructureModeKHR): VkCopyAccelerationStructureToMemoryInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.src = src
  result.dst = dst
  result.mode = mode

proc newVkCopyMemoryToAccelerationStructureInfoKHR*(sType: VkStructureType, pNext: pointer = nil, src: VkDeviceOrHostAddressConstKHR, dst: VkAccelerationStructureKHR, mode: VkCopyAccelerationStructureModeKHR): VkCopyMemoryToAccelerationStructureInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.src = src
  result.dst = dst
  result.mode = mode

proc newVkRayTracingPipelineInterfaceCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, maxPayloadSize: uint32, maxAttributeSize: uint32, maxCallableSize: uint32): VkRayTracingPipelineInterfaceCreateInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.maxPayloadSize = maxPayloadSize
  result.maxAttributeSize = maxAttributeSize
  result.maxCallableSize = maxCallableSize

proc newVkDeferredOperationInfoKHR*(sType: VkStructureType, pNext: pointer = nil, operationHandle: VkDeferredOperationKHR): VkDeferredOperationInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.operationHandle = operationHandle

proc newVkPipelineLibraryCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, libraryCount: uint32, pLibraries: ptr VkPipeline): VkPipelineLibraryCreateInfoKHR =
  result.sType = sType
  result.pNext = pNext
  result.libraryCount = libraryCount
  result.pLibraries = pLibraries

proc newVkPhysicalDeviceExtendedDynamicStateFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, extendedDynamicState: VkBool32): VkPhysicalDeviceExtendedDynamicStateFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.extendedDynamicState = extendedDynamicState

proc newVkRenderPassTransformBeginInfoQCOM*(sType: VkStructureType, pNext: pointer = nil, transform: VkSurfaceTransformFlagBitsKHR): VkRenderPassTransformBeginInfoQCOM =
  result.sType = sType
  result.pNext = pNext
  result.transform = transform

proc newVkCommandBufferInheritanceRenderPassTransformInfoQCOM*(sType: VkStructureType, pNext: pointer = nil, transform: VkSurfaceTransformFlagBitsKHR, renderArea: VkRect2D): VkCommandBufferInheritanceRenderPassTransformInfoQCOM =
  result.sType = sType
  result.pNext = pNext
  result.transform = transform
  result.renderArea = renderArea

proc newVkPhysicalDeviceDiagnosticsConfigFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, diagnosticsConfig: VkBool32): VkPhysicalDeviceDiagnosticsConfigFeaturesNV =
  result.sType = sType
  result.pNext = pNext
  result.diagnosticsConfig = diagnosticsConfig

proc newVkDeviceDiagnosticsConfigCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, flags: VkDeviceDiagnosticsConfigFlagsNV = 0.VkDeviceDiagnosticsConfigFlagsNV): VkDeviceDiagnosticsConfigCreateInfoNV =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags

proc newVkPhysicalDeviceRobustness2FeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, robustBufferAccess2: VkBool32, robustImageAccess2: VkBool32, nullDescriptor: VkBool32): VkPhysicalDeviceRobustness2FeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.robustBufferAccess2 = robustBufferAccess2
  result.robustImageAccess2 = robustImageAccess2
  result.nullDescriptor = nullDescriptor

proc newVkPhysicalDeviceRobustness2PropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, robustStorageBufferAccessSizeAlignment: VkDeviceSize, robustUniformBufferAccessSizeAlignment: VkDeviceSize): VkPhysicalDeviceRobustness2PropertiesEXT =
  result.sType = sType
  result.pNext = pNext
  result.robustStorageBufferAccessSizeAlignment = robustStorageBufferAccessSizeAlignment
  result.robustUniformBufferAccessSizeAlignment = robustUniformBufferAccessSizeAlignment

proc newVkPhysicalDeviceImageRobustnessFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, robustImageAccess: VkBool32): VkPhysicalDeviceImageRobustnessFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.robustImageAccess = robustImageAccess

proc newVkPhysicalDevice4444FormatsFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, formatA4R4G4B4: VkBool32, formatA4B4G4R4: VkBool32): VkPhysicalDevice4444FormatsFeaturesEXT =
  result.sType = sType
  result.pNext = pNext
  result.formatA4R4G4B4 = formatA4R4G4B4
  result.formatA4B4G4R4 = formatA4B4G4R4

# Procs
var
  vkCreateInstance*: proc(pCreateInfo: ptr VkInstanceCreateInfo , pAllocator: ptr VkAllocationCallbacks , pInstance: ptr VkInstance ): VkResult {.stdcall.}
  vkDestroyInstance*: proc(instance: VkInstance, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkEnumeratePhysicalDevices*: proc(instance: VkInstance, pPhysicalDeviceCount: ptr uint32 , pPhysicalDevices: ptr VkPhysicalDevice ): VkResult {.stdcall.}
  vkGetDeviceProcAddr*: proc(device: VkDevice, pName: cstring ): PFN_vkVoidFunction {.stdcall.}
  vkGetInstanceProcAddr*: proc(instance: VkInstance, pName: cstring ): PFN_vkVoidFunction {.stdcall.}
  vkGetPhysicalDeviceProperties*: proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties ): void {.stdcall.}
  vkGetPhysicalDeviceQueueFamilyProperties*: proc(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: ptr uint32 , pQueueFamilyProperties: ptr VkQueueFamilyProperties ): void {.stdcall.}
  vkGetPhysicalDeviceMemoryProperties*: proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties ): void {.stdcall.}
  vkGetPhysicalDeviceFeatures*: proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures ): void {.stdcall.}
  vkGetPhysicalDeviceFormatProperties*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties ): void {.stdcall.}
  vkGetPhysicalDeviceImageFormatProperties*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, `type`: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: ptr VkImageFormatProperties ): VkResult {.stdcall.}
  vkCreateDevice*: proc(physicalDevice: VkPhysicalDevice, pCreateInfo: ptr VkDeviceCreateInfo , pAllocator: ptr VkAllocationCallbacks , pDevice: ptr VkDevice ): VkResult {.stdcall.}
  vkDestroyDevice*: proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkEnumerateInstanceVersion*: proc(pApiVersion: ptr uint32 ): VkResult {.stdcall.}
  vkEnumerateInstanceLayerProperties*: proc(pPropertyCount: ptr uint32 , pProperties: ptr VkLayerProperties ): VkResult {.stdcall.}
  vkEnumerateInstanceExtensionProperties*: proc(pLayerName: cstring , pPropertyCount: ptr uint32 , pProperties: ptr VkExtensionProperties ): VkResult {.stdcall.}
  vkEnumerateDeviceLayerProperties*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkLayerProperties ): VkResult {.stdcall.}
  vkEnumerateDeviceExtensionProperties*: proc(physicalDevice: VkPhysicalDevice, pLayerName: cstring , pPropertyCount: ptr uint32 , pProperties: ptr VkExtensionProperties ): VkResult {.stdcall.}
  vkGetDeviceQueue*: proc(device: VkDevice, queueFamilyIndex: uint32, queueIndex: uint32, pQueue: ptr VkQueue ): void {.stdcall.}
  vkQueueSubmit*: proc(queue: VkQueue, submitCount: uint32, pSubmits: ptr VkSubmitInfo , fence: VkFence): VkResult {.stdcall.}
  vkQueueWaitIdle*: proc(queue: VkQueue): VkResult {.stdcall.}
  vkDeviceWaitIdle*: proc(device: VkDevice): VkResult {.stdcall.}
  vkAllocateMemory*: proc(device: VkDevice, pAllocateInfo: ptr VkMemoryAllocateInfo , pAllocator: ptr VkAllocationCallbacks , pMemory: ptr VkDeviceMemory ): VkResult {.stdcall.}
  vkFreeMemory*: proc(device: VkDevice, memory: VkDeviceMemory, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkMapMemory*: proc(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: ptr pointer ): VkResult {.stdcall.}
  vkUnmapMemory*: proc(device: VkDevice, memory: VkDeviceMemory): void {.stdcall.}
  vkFlushMappedMemoryRanges*: proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange ): VkResult {.stdcall.}
  vkInvalidateMappedMemoryRanges*: proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange ): VkResult {.stdcall.}
  vkGetDeviceMemoryCommitment*: proc(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: ptr VkDeviceSize ): void {.stdcall.}
  vkGetBufferMemoryRequirements*: proc(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: ptr VkMemoryRequirements ): void {.stdcall.}
  vkBindBufferMemory*: proc(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.}
  vkGetImageMemoryRequirements*: proc(device: VkDevice, image: VkImage, pMemoryRequirements: ptr VkMemoryRequirements ): void {.stdcall.}
  vkBindImageMemory*: proc(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.}
  vkGetImageSparseMemoryRequirements*: proc(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: ptr uint32 , pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements ): void {.stdcall.}
  vkGetPhysicalDeviceSparseImageFormatProperties*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, `type`: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: ptr uint32 , pProperties: ptr VkSparseImageFormatProperties ): void {.stdcall.}
  vkQueueBindSparse*: proc(queue: VkQueue, bindInfoCount: uint32, pBindInfo: ptr VkBindSparseInfo , fence: VkFence): VkResult {.stdcall.}
  vkCreateFence*: proc(device: VkDevice, pCreateInfo: ptr VkFenceCreateInfo , pAllocator: ptr VkAllocationCallbacks , pFence: ptr VkFence ): VkResult {.stdcall.}
  vkDestroyFence*: proc(device: VkDevice, fence: VkFence, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkResetFences*: proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence ): VkResult {.stdcall.}
  vkGetFenceStatus*: proc(device: VkDevice, fence: VkFence): VkResult {.stdcall.}
  vkWaitForFences*: proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence , waitAll: VkBool32, timeout: uint64): VkResult {.stdcall.}
  vkCreateSemaphore*: proc(device: VkDevice, pCreateInfo: ptr VkSemaphoreCreateInfo , pAllocator: ptr VkAllocationCallbacks , pSemaphore: ptr VkSemaphore ): VkResult {.stdcall.}
  vkDestroySemaphore*: proc(device: VkDevice, semaphore: VkSemaphore, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreateEvent*: proc(device: VkDevice, pCreateInfo: ptr VkEventCreateInfo , pAllocator: ptr VkAllocationCallbacks , pEvent: ptr VkEvent ): VkResult {.stdcall.}
  vkDestroyEvent*: proc(device: VkDevice, event: VkEvent, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetEventStatus*: proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}
  vkSetEvent*: proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}
  vkResetEvent*: proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}
  vkCreateQueryPool*: proc(device: VkDevice, pCreateInfo: ptr VkQueryPoolCreateInfo , pAllocator: ptr VkAllocationCallbacks , pQueryPool: ptr VkQueryPool ): VkResult {.stdcall.}
  vkDestroyQueryPool*: proc(device: VkDevice, queryPool: VkQueryPool, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetQueryPoolResults*: proc(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32, dataSize: uint, pData: pointer , stride: VkDeviceSize, flags: VkQueryResultFlags): VkResult {.stdcall.}
  vkResetQueryPool*: proc(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32): void {.stdcall.}
  vkCreateBuffer*: proc(device: VkDevice, pCreateInfo: ptr VkBufferCreateInfo , pAllocator: ptr VkAllocationCallbacks , pBuffer: ptr VkBuffer ): VkResult {.stdcall.}
  vkDestroyBuffer*: proc(device: VkDevice, buffer: VkBuffer, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreateBufferView*: proc(device: VkDevice, pCreateInfo: ptr VkBufferViewCreateInfo , pAllocator: ptr VkAllocationCallbacks , pView: ptr VkBufferView ): VkResult {.stdcall.}
  vkDestroyBufferView*: proc(device: VkDevice, bufferView: VkBufferView, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreateImage*: proc(device: VkDevice, pCreateInfo: ptr VkImageCreateInfo , pAllocator: ptr VkAllocationCallbacks , pImage: ptr VkImage ): VkResult {.stdcall.}
  vkDestroyImage*: proc(device: VkDevice, image: VkImage, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetImageSubresourceLayout*: proc(device: VkDevice, image: VkImage, pSubresource: ptr VkImageSubresource , pLayout: ptr VkSubresourceLayout ): void {.stdcall.}
  vkCreateImageView*: proc(device: VkDevice, pCreateInfo: ptr VkImageViewCreateInfo , pAllocator: ptr VkAllocationCallbacks , pView: ptr VkImageView ): VkResult {.stdcall.}
  vkDestroyImageView*: proc(device: VkDevice, imageView: VkImageView, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreateShaderModule*: proc(device: VkDevice, pCreateInfo: ptr VkShaderModuleCreateInfo , pAllocator: ptr VkAllocationCallbacks , pShaderModule: ptr VkShaderModule ): VkResult {.stdcall.}
  vkDestroyShaderModule*: proc(device: VkDevice, shaderModule: VkShaderModule, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreatePipelineCache*: proc(device: VkDevice, pCreateInfo: ptr VkPipelineCacheCreateInfo , pAllocator: ptr VkAllocationCallbacks , pPipelineCache: ptr VkPipelineCache ): VkResult {.stdcall.}
  vkDestroyPipelineCache*: proc(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetPipelineCacheData*: proc(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: ptr uint , pData: pointer ): VkResult {.stdcall.}
  vkMergePipelineCaches*: proc(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: uint32, pSrcCaches: ptr VkPipelineCache ): VkResult {.stdcall.}
  vkCreateGraphicsPipelines*: proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkGraphicsPipelineCreateInfo , pAllocator: ptr VkAllocationCallbacks , pPipelines: ptr VkPipeline ): VkResult {.stdcall.}
  vkCreateComputePipelines*: proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkComputePipelineCreateInfo , pAllocator: ptr VkAllocationCallbacks , pPipelines: ptr VkPipeline ): VkResult {.stdcall.}
  vkDestroyPipeline*: proc(device: VkDevice, pipeline: VkPipeline, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreatePipelineLayout*: proc(device: VkDevice, pCreateInfo: ptr VkPipelineLayoutCreateInfo , pAllocator: ptr VkAllocationCallbacks , pPipelineLayout: ptr VkPipelineLayout ): VkResult {.stdcall.}
  vkDestroyPipelineLayout*: proc(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreateSampler*: proc(device: VkDevice, pCreateInfo: ptr VkSamplerCreateInfo , pAllocator: ptr VkAllocationCallbacks , pSampler: ptr VkSampler ): VkResult {.stdcall.}
  vkDestroySampler*: proc(device: VkDevice, sampler: VkSampler, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreateDescriptorSetLayout*: proc(device: VkDevice, pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo , pAllocator: ptr VkAllocationCallbacks , pSetLayout: ptr VkDescriptorSetLayout ): VkResult {.stdcall.}
  vkDestroyDescriptorSetLayout*: proc(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreateDescriptorPool*: proc(device: VkDevice, pCreateInfo: ptr VkDescriptorPoolCreateInfo , pAllocator: ptr VkAllocationCallbacks , pDescriptorPool: ptr VkDescriptorPool ): VkResult {.stdcall.}
  vkDestroyDescriptorPool*: proc(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkResetDescriptorPool*: proc(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags): VkResult {.stdcall.}
  vkAllocateDescriptorSets*: proc(device: VkDevice, pAllocateInfo: ptr VkDescriptorSetAllocateInfo , pDescriptorSets: ptr VkDescriptorSet ): VkResult {.stdcall.}
  vkFreeDescriptorSets*: proc(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: uint32, pDescriptorSets: ptr VkDescriptorSet ): VkResult {.stdcall.}
  vkUpdateDescriptorSets*: proc(device: VkDevice, descriptorWriteCount: uint32, pDescriptorWrites: ptr VkWriteDescriptorSet , descriptorCopyCount: uint32, pDescriptorCopies: ptr VkCopyDescriptorSet ): void {.stdcall.}
  vkCreateFramebuffer*: proc(device: VkDevice, pCreateInfo: ptr VkFramebufferCreateInfo , pAllocator: ptr VkAllocationCallbacks , pFramebuffer: ptr VkFramebuffer ): VkResult {.stdcall.}
  vkDestroyFramebuffer*: proc(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreateRenderPass*: proc(device: VkDevice, pCreateInfo: ptr VkRenderPassCreateInfo , pAllocator: ptr VkAllocationCallbacks , pRenderPass: ptr VkRenderPass ): VkResult {.stdcall.}
  vkDestroyRenderPass*: proc(device: VkDevice, renderPass: VkRenderPass, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetRenderAreaGranularity*: proc(device: VkDevice, renderPass: VkRenderPass, pGranularity: ptr VkExtent2D ): void {.stdcall.}
  vkCreateCommandPool*: proc(device: VkDevice, pCreateInfo: ptr VkCommandPoolCreateInfo , pAllocator: ptr VkAllocationCallbacks , pCommandPool: ptr VkCommandPool ): VkResult {.stdcall.}
  vkDestroyCommandPool*: proc(device: VkDevice, commandPool: VkCommandPool, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkResetCommandPool*: proc(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags): VkResult {.stdcall.}
  vkAllocateCommandBuffers*: proc(device: VkDevice, pAllocateInfo: ptr VkCommandBufferAllocateInfo , pCommandBuffers: ptr VkCommandBuffer ): VkResult {.stdcall.}
  vkFreeCommandBuffers*: proc(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer ): void {.stdcall.}
  vkBeginCommandBuffer*: proc(commandBuffer: VkCommandBuffer, pBeginInfo: ptr VkCommandBufferBeginInfo ): VkResult {.stdcall.}
  vkEndCommandBuffer*: proc(commandBuffer: VkCommandBuffer): VkResult {.stdcall.}
  vkResetCommandBuffer*: proc(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags): VkResult {.stdcall.}
  vkCmdBindPipeline*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline): void {.stdcall.}
  vkCmdSetViewport*: proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewports: ptr VkViewport ): void {.stdcall.}
  vkCmdSetScissor*: proc(commandBuffer: VkCommandBuffer, firstScissor: uint32, scissorCount: uint32, pScissors: ptr VkRect2D ): void {.stdcall.}
  vkCmdSetLineWidth*: proc(commandBuffer: VkCommandBuffer, lineWidth: float32): void {.stdcall.}
  vkCmdSetDepthBias*: proc(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: float32, depthBiasClamp: float32, depthBiasSlopeFactor: float32): void {.stdcall.}
  vkCmdSetBlendConstants*: proc(commandBuffer: VkCommandBuffer, blendConstants: array[4, float32]): void {.stdcall.}
  vkCmdSetDepthBounds*: proc(commandBuffer: VkCommandBuffer, minDepthBounds: float32, maxDepthBounds: float32): void {.stdcall.}
  vkCmdSetStencilCompareMask*: proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: uint32): void {.stdcall.}
  vkCmdSetStencilWriteMask*: proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: uint32): void {.stdcall.}
  vkCmdSetStencilReference*: proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: uint32): void {.stdcall.}
  vkCmdBindDescriptorSets*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: uint32, descriptorSetCount: uint32, pDescriptorSets: ptr VkDescriptorSet , dynamicOffsetCount: uint32, pDynamicOffsets: ptr uint32 ): void {.stdcall.}
  vkCmdBindIndexBuffer*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType): void {.stdcall.}
  vkCmdBindVertexBuffers*: proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer , pOffsets: ptr VkDeviceSize ): void {.stdcall.}
  vkCmdDraw*: proc(commandBuffer: VkCommandBuffer, vertexCount: uint32, instanceCount: uint32, firstVertex: uint32, firstInstance: uint32): void {.stdcall.}
  vkCmdDrawIndexed*: proc(commandBuffer: VkCommandBuffer, indexCount: uint32, instanceCount: uint32, firstIndex: uint32, vertexOffset: int32, firstInstance: uint32): void {.stdcall.}
  vkCmdDrawIndirect*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}
  vkCmdDrawIndexedIndirect*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}
  vkCmdDispatch*: proc(commandBuffer: VkCommandBuffer, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}
  vkCmdDispatchIndirect*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize): void {.stdcall.}
  vkCmdCopyBuffer*: proc(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: uint32, pRegions: ptr VkBufferCopy ): void {.stdcall.}
  vkCmdCopyImage*: proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageCopy ): void {.stdcall.}
  vkCmdBlitImage*: proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageBlit , filter: VkFilter): void {.stdcall.}
  vkCmdCopyBufferToImage*: proc(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkBufferImageCopy ): void {.stdcall.}
  vkCmdCopyImageToBuffer*: proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: uint32, pRegions: ptr VkBufferImageCopy ): void {.stdcall.}
  vkCmdUpdateBuffer*: proc(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: pointer ): void {.stdcall.}
  vkCmdFillBuffer*: proc(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: uint32): void {.stdcall.}
  vkCmdClearColorImage*: proc(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: ptr VkClearColorValue , rangeCount: uint32, pRanges: ptr VkImageSubresourceRange ): void {.stdcall.}
  vkCmdClearDepthStencilImage*: proc(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: ptr VkClearDepthStencilValue , rangeCount: uint32, pRanges: ptr VkImageSubresourceRange ): void {.stdcall.}
  vkCmdClearAttachments*: proc(commandBuffer: VkCommandBuffer, attachmentCount: uint32, pAttachments: ptr VkClearAttachment , rectCount: uint32, pRects: ptr VkClearRect ): void {.stdcall.}
  vkCmdResolveImage*: proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageResolve ): void {.stdcall.}
  vkCmdSetEvent*: proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags): void {.stdcall.}
  vkCmdResetEvent*: proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags): void {.stdcall.}
  vkCmdWaitEvents*: proc(commandBuffer: VkCommandBuffer, eventCount: uint32, pEvents: ptr VkEvent , srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, memoryBarrierCount: uint32, pMemoryBarriers: ptr VkMemoryBarrier , bufferMemoryBarrierCount: uint32, pBufferMemoryBarriers: ptr VkBufferMemoryBarrier , imageMemoryBarrierCount: uint32, pImageMemoryBarriers: ptr VkImageMemoryBarrier ): void {.stdcall.}
  vkCmdPipelineBarrier*: proc(commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: uint32, pMemoryBarriers: ptr VkMemoryBarrier , bufferMemoryBarrierCount: uint32, pBufferMemoryBarriers: ptr VkBufferMemoryBarrier , imageMemoryBarrierCount: uint32, pImageMemoryBarriers: ptr VkImageMemoryBarrier ): void {.stdcall.}
  vkCmdBeginQuery*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, flags: VkQueryControlFlags): void {.stdcall.}
  vkCmdEndQuery*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32): void {.stdcall.}
  vkCmdBeginConditionalRenderingEXT*: proc(commandBuffer: VkCommandBuffer, pConditionalRenderingBegin: ptr VkConditionalRenderingBeginInfoEXT ): void {.stdcall.}
  vkCmdEndConditionalRenderingEXT*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.}
  vkCmdResetQueryPool*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32): void {.stdcall.}
  vkCmdWriteTimestamp*: proc(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, queryPool: VkQueryPool, query: uint32): void {.stdcall.}
  vkCmdCopyQueryPoolResults*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags): void {.stdcall.}
  vkCmdPushConstants*: proc(commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: uint32, size: uint32, pValues: pointer ): void {.stdcall.}
  vkCmdBeginRenderPass*: proc(commandBuffer: VkCommandBuffer, pRenderPassBegin: ptr VkRenderPassBeginInfo , contents: VkSubpassContents): void {.stdcall.}
  vkCmdNextSubpass*: proc(commandBuffer: VkCommandBuffer, contents: VkSubpassContents): void {.stdcall.}
  vkCmdEndRenderPass*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.}
  vkCmdExecuteCommands*: proc(commandBuffer: VkCommandBuffer, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer ): void {.stdcall.}
  vkCreateAndroidSurfaceKHR*: proc(instance: VkInstance, pCreateInfo: ptr VkAndroidSurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceDisplayPropertiesKHR*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayPropertiesKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceDisplayPlanePropertiesKHR*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayPlanePropertiesKHR ): VkResult {.stdcall.}
  vkGetDisplayPlaneSupportedDisplaysKHR*: proc(physicalDevice: VkPhysicalDevice, planeIndex: uint32, pDisplayCount: ptr uint32 , pDisplays: ptr VkDisplayKHR ): VkResult {.stdcall.}
  vkGetDisplayModePropertiesKHR*: proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayModePropertiesKHR ): VkResult {.stdcall.}
  vkCreateDisplayModeKHR*: proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: ptr VkDisplayModeCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pMode: ptr VkDisplayModeKHR ): VkResult {.stdcall.}
  vkGetDisplayPlaneCapabilitiesKHR*: proc(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: uint32, pCapabilities: ptr VkDisplayPlaneCapabilitiesKHR ): VkResult {.stdcall.}
  vkCreateDisplayPlaneSurfaceKHR*: proc(instance: VkInstance, pCreateInfo: ptr VkDisplaySurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkCreateSharedSwapchainsKHR*: proc(device: VkDevice, swapchainCount: uint32, pCreateInfos: ptr VkSwapchainCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSwapchains: ptr VkSwapchainKHR ): VkResult {.stdcall.}
  vkDestroySurfaceKHR*: proc(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetPhysicalDeviceSurfaceSupportKHR*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, surface: VkSurfaceKHR, pSupported: ptr VkBool32 ): VkResult {.stdcall.}
  vkGetPhysicalDeviceSurfaceCapabilitiesKHR*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: ptr VkSurfaceCapabilitiesKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceSurfaceFormatsKHR*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: ptr uint32 , pSurfaceFormats: ptr VkSurfaceFormatKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceSurfacePresentModesKHR*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: ptr uint32 , pPresentModes: ptr VkPresentModeKHR ): VkResult {.stdcall.}
  vkCreateSwapchainKHR*: proc(device: VkDevice, pCreateInfo: ptr VkSwapchainCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSwapchain: ptr VkSwapchainKHR ): VkResult {.stdcall.}
  vkDestroySwapchainKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetSwapchainImagesKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: ptr uint32 , pSwapchainImages: ptr VkImage ): VkResult {.stdcall.}
  vkAcquireNextImageKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR, timeout: uint64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: ptr uint32 ): VkResult {.stdcall.}
  vkQueuePresentKHR*: proc(queue: VkQueue, pPresentInfo: ptr VkPresentInfoKHR ): VkResult {.stdcall.}
  vkCreateViSurfaceNN*: proc(instance: VkInstance, pCreateInfo: ptr VkViSurfaceCreateInfoNN , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkCreateWaylandSurfaceKHR*: proc(instance: VkInstance, pCreateInfo: ptr VkWaylandSurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceWaylandPresentationSupportKHR*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, display: ptr wl_display ): VkBool32 {.stdcall.}
  vkCreateWin32SurfaceKHR*: proc(instance: VkInstance, pCreateInfo: ptr VkWin32SurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceWin32PresentationSupportKHR*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32): VkBool32 {.stdcall.}
  vkCreateXlibSurfaceKHR*: proc(instance: VkInstance, pCreateInfo: ptr VkXlibSurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceXlibPresentationSupportKHR*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, dpy: ptr Display , visualID: VisualID): VkBool32 {.stdcall.}
  vkCreateXcbSurfaceKHR*: proc(instance: VkInstance, pCreateInfo: ptr VkXcbSurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceXcbPresentationSupportKHR*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, connection: ptr xcb_connection_t , visual_id: xcb_visualid_t): VkBool32 {.stdcall.}
  vkCreateDirectFBSurfaceEXT*: proc(instance: VkInstance, pCreateInfo: ptr VkDirectFBSurfaceCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceDirectFBPresentationSupportEXT*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, dfb: ptr IDirectFB ): VkBool32 {.stdcall.}
  vkCreateImagePipeSurfaceFUCHSIA*: proc(instance: VkInstance, pCreateInfo: ptr VkImagePipeSurfaceCreateInfoFUCHSIA , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkCreateStreamDescriptorSurfaceGGP*: proc(instance: VkInstance, pCreateInfo: ptr VkStreamDescriptorSurfaceCreateInfoGGP , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkCreateDebugReportCallbackEXT*: proc(instance: VkInstance, pCreateInfo: ptr VkDebugReportCallbackCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pCallback: ptr VkDebugReportCallbackEXT ): VkResult {.stdcall.}
  vkDestroyDebugReportCallbackEXT*: proc(instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkDebugReportMessageEXT*: proc(instance: VkInstance, flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, `object`: uint64, location: uint, messageCode: int32, pLayerPrefix: cstring , pMessage: cstring ): void {.stdcall.}
  vkDebugMarkerSetObjectNameEXT*: proc(device: VkDevice, pNameInfo: ptr VkDebugMarkerObjectNameInfoEXT ): VkResult {.stdcall.}
  vkDebugMarkerSetObjectTagEXT*: proc(device: VkDevice, pTagInfo: ptr VkDebugMarkerObjectTagInfoEXT ): VkResult {.stdcall.}
  vkCmdDebugMarkerBeginEXT*: proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkDebugMarkerMarkerInfoEXT ): void {.stdcall.}
  vkCmdDebugMarkerEndEXT*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.}
  vkCmdDebugMarkerInsertEXT*: proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkDebugMarkerMarkerInfoEXT ): void {.stdcall.}
  vkGetPhysicalDeviceExternalImageFormatPropertiesNV*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, `type`: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, externalHandleType: VkExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: ptr VkExternalImageFormatPropertiesNV ): VkResult {.stdcall.}
  vkGetMemoryWin32HandleNV*: proc(device: VkDevice, memory: VkDeviceMemory, handleType: VkExternalMemoryHandleTypeFlagsNV, pHandle: ptr HANDLE ): VkResult {.stdcall.}
  vkCmdExecuteGeneratedCommandsNV*: proc(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: ptr VkGeneratedCommandsInfoNV ): void {.stdcall.}
  vkCmdPreprocessGeneratedCommandsNV*: proc(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: ptr VkGeneratedCommandsInfoNV ): void {.stdcall.}
  vkCmdBindPipelineShaderGroupNV*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, groupIndex: uint32): void {.stdcall.}
  vkGetGeneratedCommandsMemoryRequirementsNV*: proc(device: VkDevice, pInfo: ptr VkGeneratedCommandsMemoryRequirementsInfoNV , pMemoryRequirements: ptr VkMemoryRequirements2 ): void {.stdcall.}
  vkCreateIndirectCommandsLayoutNV*: proc(device: VkDevice, pCreateInfo: ptr VkIndirectCommandsLayoutCreateInfoNV , pAllocator: ptr VkAllocationCallbacks , pIndirectCommandsLayout: ptr VkIndirectCommandsLayoutNV ): VkResult {.stdcall.}
  vkDestroyIndirectCommandsLayoutNV*: proc(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutNV, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetPhysicalDeviceFeatures2*: proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures2 ): void {.stdcall.}
  vkGetPhysicalDeviceProperties2*: proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties2 ): void {.stdcall.}
  vkGetPhysicalDeviceFormatProperties2*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties2 ): void {.stdcall.}
  vkGetPhysicalDeviceImageFormatProperties2*: proc(physicalDevice: VkPhysicalDevice, pImageFormatInfo: ptr VkPhysicalDeviceImageFormatInfo2 , pImageFormatProperties: ptr VkImageFormatProperties2 ): VkResult {.stdcall.}
  vkGetPhysicalDeviceQueueFamilyProperties2*: proc(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: ptr uint32 , pQueueFamilyProperties: ptr VkQueueFamilyProperties2 ): void {.stdcall.}
  vkGetPhysicalDeviceMemoryProperties2*: proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties2 ): void {.stdcall.}
  vkGetPhysicalDeviceSparseImageFormatProperties2*: proc(physicalDevice: VkPhysicalDevice, pFormatInfo: ptr VkPhysicalDeviceSparseImageFormatInfo2 , pPropertyCount: ptr uint32 , pProperties: ptr VkSparseImageFormatProperties2 ): void {.stdcall.}
  vkCmdPushDescriptorSetKHR*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32, descriptorWriteCount: uint32, pDescriptorWrites: ptr VkWriteDescriptorSet ): void {.stdcall.}
  vkTrimCommandPool*: proc(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags): void {.stdcall.}
  vkGetPhysicalDeviceExternalBufferProperties*: proc(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: ptr VkPhysicalDeviceExternalBufferInfo , pExternalBufferProperties: ptr VkExternalBufferProperties ): void {.stdcall.}
  vkGetMemoryWin32HandleKHR*: proc(device: VkDevice, pGetWin32HandleInfo: ptr VkMemoryGetWin32HandleInfoKHR , pHandle: ptr HANDLE ): VkResult {.stdcall.}
  vkGetMemoryWin32HandlePropertiesKHR*: proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, handle: HANDLE, pMemoryWin32HandleProperties: ptr VkMemoryWin32HandlePropertiesKHR ): VkResult {.stdcall.}
  vkGetMemoryFdKHR*: proc(device: VkDevice, pGetFdInfo: ptr VkMemoryGetFdInfoKHR , pFd: ptr int ): VkResult {.stdcall.}
  vkGetMemoryFdPropertiesKHR*: proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, fd: int, pMemoryFdProperties: ptr VkMemoryFdPropertiesKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceExternalSemaphoreProperties*: proc(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: ptr VkPhysicalDeviceExternalSemaphoreInfo , pExternalSemaphoreProperties: ptr VkExternalSemaphoreProperties ): void {.stdcall.}
  vkGetSemaphoreWin32HandleKHR*: proc(device: VkDevice, pGetWin32HandleInfo: ptr VkSemaphoreGetWin32HandleInfoKHR , pHandle: ptr HANDLE ): VkResult {.stdcall.}
  vkImportSemaphoreWin32HandleKHR*: proc(device: VkDevice, pImportSemaphoreWin32HandleInfo: ptr VkImportSemaphoreWin32HandleInfoKHR ): VkResult {.stdcall.}
  vkGetSemaphoreFdKHR*: proc(device: VkDevice, pGetFdInfo: ptr VkSemaphoreGetFdInfoKHR , pFd: ptr int ): VkResult {.stdcall.}
  vkImportSemaphoreFdKHR*: proc(device: VkDevice, pImportSemaphoreFdInfo: ptr VkImportSemaphoreFdInfoKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceExternalFenceProperties*: proc(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: ptr VkPhysicalDeviceExternalFenceInfo , pExternalFenceProperties: ptr VkExternalFenceProperties ): void {.stdcall.}
  vkGetFenceWin32HandleKHR*: proc(device: VkDevice, pGetWin32HandleInfo: ptr VkFenceGetWin32HandleInfoKHR , pHandle: ptr HANDLE ): VkResult {.stdcall.}
  vkImportFenceWin32HandleKHR*: proc(device: VkDevice, pImportFenceWin32HandleInfo: ptr VkImportFenceWin32HandleInfoKHR ): VkResult {.stdcall.}
  vkGetFenceFdKHR*: proc(device: VkDevice, pGetFdInfo: ptr VkFenceGetFdInfoKHR , pFd: ptr int ): VkResult {.stdcall.}
  vkImportFenceFdKHR*: proc(device: VkDevice, pImportFenceFdInfo: ptr VkImportFenceFdInfoKHR ): VkResult {.stdcall.}
  vkReleaseDisplayEXT*: proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR): VkResult {.stdcall.}
  vkAcquireXlibDisplayEXT*: proc(physicalDevice: VkPhysicalDevice, dpy: ptr Display , display: VkDisplayKHR): VkResult {.stdcall.}
  vkGetRandROutputDisplayEXT*: proc(physicalDevice: VkPhysicalDevice, dpy: ptr Display , rrOutput: RROutput, pDisplay: ptr VkDisplayKHR ): VkResult {.stdcall.}
  vkDisplayPowerControlEXT*: proc(device: VkDevice, display: VkDisplayKHR, pDisplayPowerInfo: ptr VkDisplayPowerInfoEXT ): VkResult {.stdcall.}
  vkRegisterDeviceEventEXT*: proc(device: VkDevice, pDeviceEventInfo: ptr VkDeviceEventInfoEXT , pAllocator: ptr VkAllocationCallbacks , pFence: ptr VkFence ): VkResult {.stdcall.}
  vkRegisterDisplayEventEXT*: proc(device: VkDevice, display: VkDisplayKHR, pDisplayEventInfo: ptr VkDisplayEventInfoEXT , pAllocator: ptr VkAllocationCallbacks , pFence: ptr VkFence ): VkResult {.stdcall.}
  vkGetSwapchainCounterEXT*: proc(device: VkDevice, swapchain: VkSwapchainKHR, counter: VkSurfaceCounterFlagBitsEXT, pCounterValue: ptr uint64 ): VkResult {.stdcall.}
  vkGetPhysicalDeviceSurfaceCapabilities2EXT*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: ptr VkSurfaceCapabilities2EXT ): VkResult {.stdcall.}
  vkEnumeratePhysicalDeviceGroups*: proc(instance: VkInstance, pPhysicalDeviceGroupCount: ptr uint32 , pPhysicalDeviceGroupProperties: ptr VkPhysicalDeviceGroupProperties ): VkResult {.stdcall.}
  vkGetDeviceGroupPeerMemoryFeatures*: proc(device: VkDevice, heapIndex: uint32, localDeviceIndex: uint32, remoteDeviceIndex: uint32, pPeerMemoryFeatures: ptr VkPeerMemoryFeatureFlags ): void {.stdcall.}
  vkBindBufferMemory2*: proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindBufferMemoryInfo ): VkResult {.stdcall.}
  vkBindImageMemory2*: proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindImageMemoryInfo ): VkResult {.stdcall.}
  vkCmdSetDeviceMask*: proc(commandBuffer: VkCommandBuffer, deviceMask: uint32): void {.stdcall.}
  vkGetDeviceGroupPresentCapabilitiesKHR*: proc(device: VkDevice, pDeviceGroupPresentCapabilities: ptr VkDeviceGroupPresentCapabilitiesKHR ): VkResult {.stdcall.}
  vkGetDeviceGroupSurfacePresentModesKHR*: proc(device: VkDevice, surface: VkSurfaceKHR, pModes: ptr VkDeviceGroupPresentModeFlagsKHR ): VkResult {.stdcall.}
  vkAcquireNextImage2KHR*: proc(device: VkDevice, pAcquireInfo: ptr VkAcquireNextImageInfoKHR , pImageIndex: ptr uint32 ): VkResult {.stdcall.}
  vkCmdDispatchBase*: proc(commandBuffer: VkCommandBuffer, baseGroupX: uint32, baseGroupY: uint32, baseGroupZ: uint32, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}
  vkGetPhysicalDevicePresentRectanglesKHR*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: ptr uint32 , pRects: ptr VkRect2D ): VkResult {.stdcall.}
  vkCreateDescriptorUpdateTemplate*: proc(device: VkDevice, pCreateInfo: ptr VkDescriptorUpdateTemplateCreateInfo , pAllocator: ptr VkAllocationCallbacks , pDescriptorUpdateTemplate: ptr VkDescriptorUpdateTemplate ): VkResult {.stdcall.}
  vkDestroyDescriptorUpdateTemplate*: proc(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkUpdateDescriptorSetWithTemplate*: proc(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: pointer ): void {.stdcall.}
  vkCmdPushDescriptorSetWithTemplateKHR*: proc(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32, pData: pointer ): void {.stdcall.}
  vkSetHdrMetadataEXT*: proc(device: VkDevice, swapchainCount: uint32, pSwapchains: ptr VkSwapchainKHR , pMetadata: ptr VkHdrMetadataEXT ): void {.stdcall.}
  vkGetSwapchainStatusKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR): VkResult {.stdcall.}
  vkGetRefreshCycleDurationGOOGLE*: proc(device: VkDevice, swapchain: VkSwapchainKHR, pDisplayTimingProperties: ptr VkRefreshCycleDurationGOOGLE ): VkResult {.stdcall.}
  vkGetPastPresentationTimingGOOGLE*: proc(device: VkDevice, swapchain: VkSwapchainKHR, pPresentationTimingCount: ptr uint32 , pPresentationTimings: ptr VkPastPresentationTimingGOOGLE ): VkResult {.stdcall.}
  vkCreateIOSSurfaceMVK*: proc(instance: VkInstance, pCreateInfo: ptr VkIOSSurfaceCreateInfoMVK , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkCreateMacOSSurfaceMVK*: proc(instance: VkInstance, pCreateInfo: ptr VkMacOSSurfaceCreateInfoMVK , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkCreateMetalSurfaceEXT*: proc(instance: VkInstance, pCreateInfo: ptr VkMetalSurfaceCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkCmdSetViewportWScalingNV*: proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewportWScalings: ptr VkViewportWScalingNV ): void {.stdcall.}
  vkCmdSetDiscardRectangleEXT*: proc(commandBuffer: VkCommandBuffer, firstDiscardRectangle: uint32, discardRectangleCount: uint32, pDiscardRectangles: ptr VkRect2D ): void {.stdcall.}
  vkCmdSetSampleLocationsEXT*: proc(commandBuffer: VkCommandBuffer, pSampleLocationsInfo: ptr VkSampleLocationsInfoEXT ): void {.stdcall.}
  vkGetPhysicalDeviceMultisamplePropertiesEXT*: proc(physicalDevice: VkPhysicalDevice, samples: VkSampleCountFlagBits, pMultisampleProperties: ptr VkMultisamplePropertiesEXT ): void {.stdcall.}
  vkGetPhysicalDeviceSurfaceCapabilities2KHR*: proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pSurfaceCapabilities: ptr VkSurfaceCapabilities2KHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceSurfaceFormats2KHR*: proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pSurfaceFormatCount: ptr uint32 , pSurfaceFormats: ptr VkSurfaceFormat2KHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceDisplayProperties2KHR*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayProperties2KHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceDisplayPlaneProperties2KHR*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayPlaneProperties2KHR ): VkResult {.stdcall.}
  vkGetDisplayModeProperties2KHR*: proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayModeProperties2KHR ): VkResult {.stdcall.}
  vkGetDisplayPlaneCapabilities2KHR*: proc(physicalDevice: VkPhysicalDevice, pDisplayPlaneInfo: ptr VkDisplayPlaneInfo2KHR , pCapabilities: ptr VkDisplayPlaneCapabilities2KHR ): VkResult {.stdcall.}
  vkGetBufferMemoryRequirements2*: proc(device: VkDevice, pInfo: ptr VkBufferMemoryRequirementsInfo2 , pMemoryRequirements: ptr VkMemoryRequirements2 ): void {.stdcall.}
  vkGetImageMemoryRequirements2*: proc(device: VkDevice, pInfo: ptr VkImageMemoryRequirementsInfo2 , pMemoryRequirements: ptr VkMemoryRequirements2 ): void {.stdcall.}
  vkGetImageSparseMemoryRequirements2*: proc(device: VkDevice, pInfo: ptr VkImageSparseMemoryRequirementsInfo2 , pSparseMemoryRequirementCount: ptr uint32 , pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements2 ): void {.stdcall.}
  vkCreateSamplerYcbcrConversion*: proc(device: VkDevice, pCreateInfo: ptr VkSamplerYcbcrConversionCreateInfo , pAllocator: ptr VkAllocationCallbacks , pYcbcrConversion: ptr VkSamplerYcbcrConversion ): VkResult {.stdcall.}
  vkDestroySamplerYcbcrConversion*: proc(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetDeviceQueue2*: proc(device: VkDevice, pQueueInfo: ptr VkDeviceQueueInfo2 , pQueue: ptr VkQueue ): void {.stdcall.}
  vkCreateValidationCacheEXT*: proc(device: VkDevice, pCreateInfo: ptr VkValidationCacheCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pValidationCache: ptr VkValidationCacheEXT ): VkResult {.stdcall.}
  vkDestroyValidationCacheEXT*: proc(device: VkDevice, validationCache: VkValidationCacheEXT, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetValidationCacheDataEXT*: proc(device: VkDevice, validationCache: VkValidationCacheEXT, pDataSize: ptr uint , pData: pointer ): VkResult {.stdcall.}
  vkMergeValidationCachesEXT*: proc(device: VkDevice, dstCache: VkValidationCacheEXT, srcCacheCount: uint32, pSrcCaches: ptr VkValidationCacheEXT ): VkResult {.stdcall.}
  vkGetDescriptorSetLayoutSupport*: proc(device: VkDevice, pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo , pSupport: ptr VkDescriptorSetLayoutSupport ): void {.stdcall.}
  vkGetSwapchainGrallocUsageANDROID*: proc(device: VkDevice, format: VkFormat, imageUsage: VkImageUsageFlags, grallocUsage: ptr int ): VkResult {.stdcall.}
  vkGetSwapchainGrallocUsage2ANDROID*: proc(device: VkDevice, format: VkFormat, imageUsage: VkImageUsageFlags, swapchainImageUsage: VkSwapchainImageUsageFlagsANDROID, grallocConsumerUsage: ptr uint64 , grallocProducerUsage: ptr uint64 ): VkResult {.stdcall.}
  vkAcquireImageANDROID*: proc(device: VkDevice, image: VkImage, nativeFenceFd: int, semaphore: VkSemaphore, fence: VkFence): VkResult {.stdcall.}
  vkQueueSignalReleaseImageANDROID*: proc(queue: VkQueue, waitSemaphoreCount: uint32, pWaitSemaphores: ptr VkSemaphore , image: VkImage, pNativeFenceFd: ptr int ): VkResult {.stdcall.}
  vkGetShaderInfoAMD*: proc(device: VkDevice, pipeline: VkPipeline, shaderStage: VkShaderStageFlagBits, infoType: VkShaderInfoTypeAMD, pInfoSize: ptr uint , pInfo: pointer ): VkResult {.stdcall.}
  vkSetLocalDimmingAMD*: proc(device: VkDevice, swapChain: VkSwapchainKHR, localDimmingEnable: VkBool32): void {.stdcall.}
  vkGetPhysicalDeviceCalibrateableTimeDomainsEXT*: proc(physicalDevice: VkPhysicalDevice, pTimeDomainCount: ptr uint32 , pTimeDomains: ptr VkTimeDomainEXT ): VkResult {.stdcall.}
  vkGetCalibratedTimestampsEXT*: proc(device: VkDevice, timestampCount: uint32, pTimestampInfos: ptr VkCalibratedTimestampInfoEXT , pTimestamps: ptr uint64 , pMaxDeviation: ptr uint64 ): VkResult {.stdcall.}
  vkSetDebugUtilsObjectNameEXT*: proc(device: VkDevice, pNameInfo: ptr VkDebugUtilsObjectNameInfoEXT ): VkResult {.stdcall.}
  vkSetDebugUtilsObjectTagEXT*: proc(device: VkDevice, pTagInfo: ptr VkDebugUtilsObjectTagInfoEXT ): VkResult {.stdcall.}
  vkQueueBeginDebugUtilsLabelEXT*: proc(queue: VkQueue, pLabelInfo: ptr VkDebugUtilsLabelEXT ): void {.stdcall.}
  vkQueueEndDebugUtilsLabelEXT*: proc(queue: VkQueue): void {.stdcall.}
  vkQueueInsertDebugUtilsLabelEXT*: proc(queue: VkQueue, pLabelInfo: ptr VkDebugUtilsLabelEXT ): void {.stdcall.}
  vkCmdBeginDebugUtilsLabelEXT*: proc(commandBuffer: VkCommandBuffer, pLabelInfo: ptr VkDebugUtilsLabelEXT ): void {.stdcall.}
  vkCmdEndDebugUtilsLabelEXT*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.}
  vkCmdInsertDebugUtilsLabelEXT*: proc(commandBuffer: VkCommandBuffer, pLabelInfo: ptr VkDebugUtilsLabelEXT ): void {.stdcall.}
  vkCreateDebugUtilsMessengerEXT*: proc(instance: VkInstance, pCreateInfo: ptr VkDebugUtilsMessengerCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pMessenger: ptr VkDebugUtilsMessengerEXT ): VkResult {.stdcall.}
  vkDestroyDebugUtilsMessengerEXT*: proc(instance: VkInstance, messenger: VkDebugUtilsMessengerEXT, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkSubmitDebugUtilsMessageEXT*: proc(instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: ptr VkDebugUtilsMessengerCallbackDataEXT ): void {.stdcall.}
  vkGetMemoryHostPointerPropertiesEXT*: proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, pHostPointer: pointer , pMemoryHostPointerProperties: ptr VkMemoryHostPointerPropertiesEXT ): VkResult {.stdcall.}
  vkCmdWriteBufferMarkerAMD*: proc(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: uint32): void {.stdcall.}
  vkCreateRenderPass2*: proc(device: VkDevice, pCreateInfo: ptr VkRenderPassCreateInfo2 , pAllocator: ptr VkAllocationCallbacks , pRenderPass: ptr VkRenderPass ): VkResult {.stdcall.}
  vkCmdBeginRenderPass2*: proc(commandBuffer: VkCommandBuffer, pRenderPassBegin: ptr VkRenderPassBeginInfo      , pSubpassBeginInfo: ptr VkSubpassBeginInfo      ): void {.stdcall.}
  vkCmdNextSubpass2*: proc(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: ptr VkSubpassBeginInfo      , pSubpassEndInfo: ptr VkSubpassEndInfo        ): void {.stdcall.}
  vkCmdEndRenderPass2*: proc(commandBuffer: VkCommandBuffer, pSubpassEndInfo: ptr VkSubpassEndInfo        ): void {.stdcall.}
  vkGetSemaphoreCounterValue*: proc(device: VkDevice, semaphore: VkSemaphore, pValue: ptr uint64 ): VkResult {.stdcall.}
  vkWaitSemaphores*: proc(device: VkDevice, pWaitInfo: ptr VkSemaphoreWaitInfo , timeout: uint64): VkResult {.stdcall.}
  vkSignalSemaphore*: proc(device: VkDevice, pSignalInfo: ptr VkSemaphoreSignalInfo ): VkResult {.stdcall.}
  vkGetAndroidHardwareBufferPropertiesANDROID*: proc(device: VkDevice, buffer: ptr AHardwareBuffer , pProperties: ptr VkAndroidHardwareBufferPropertiesANDROID ): VkResult {.stdcall.}
  vkGetMemoryAndroidHardwareBufferANDROID*: proc(device: VkDevice, pInfo: ptr VkMemoryGetAndroidHardwareBufferInfoANDROID , pBuffer: ptr ptr AHardwareBuffer ): VkResult {.stdcall.}
  vkCmdDrawIndirectCount*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}
  vkCmdDrawIndexedIndirectCount*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}
  vkCmdSetCheckpointNV*: proc(commandBuffer: VkCommandBuffer, pCheckpointMarker: pointer ): void {.stdcall.}
  vkGetQueueCheckpointDataNV*: proc(queue: VkQueue, pCheckpointDataCount: ptr uint32 , pCheckpointData: ptr VkCheckpointDataNV ): void {.stdcall.}
  vkCmdBindTransformFeedbackBuffersEXT*: proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer , pOffsets: ptr VkDeviceSize , pSizes: ptr VkDeviceSize ): void {.stdcall.}
  vkCmdBeginTransformFeedbackEXT*: proc(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32, counterBufferCount: uint32, pCounterBuffers: ptr VkBuffer , pCounterBufferOffsets: ptr VkDeviceSize ): void {.stdcall.}
  vkCmdEndTransformFeedbackEXT*: proc(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32, counterBufferCount: uint32, pCounterBuffers: ptr VkBuffer , pCounterBufferOffsets: ptr VkDeviceSize ): void {.stdcall.}
  vkCmdBeginQueryIndexedEXT*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, flags: VkQueryControlFlags, index: uint32): void {.stdcall.}
  vkCmdEndQueryIndexedEXT*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, index: uint32): void {.stdcall.}
  vkCmdDrawIndirectByteCountEXT*: proc(commandBuffer: VkCommandBuffer, instanceCount: uint32, firstInstance: uint32, counterBuffer: VkBuffer, counterBufferOffset: VkDeviceSize, counterOffset: uint32, vertexStride: uint32): void {.stdcall.}
  vkCmdSetExclusiveScissorNV*: proc(commandBuffer: VkCommandBuffer, firstExclusiveScissor: uint32, exclusiveScissorCount: uint32, pExclusiveScissors: ptr VkRect2D ): void {.stdcall.}
  vkCmdBindShadingRateImageNV*: proc(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout): void {.stdcall.}
  vkCmdSetViewportShadingRatePaletteNV*: proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pShadingRatePalettes: ptr VkShadingRatePaletteNV ): void {.stdcall.}
  vkCmdSetCoarseSampleOrderNV*: proc(commandBuffer: VkCommandBuffer, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: uint32, pCustomSampleOrders: ptr VkCoarseSampleOrderCustomNV ): void {.stdcall.}
  vkCmdDrawMeshTasksNV*: proc(commandBuffer: VkCommandBuffer, taskCount: uint32, firstTask: uint32): void {.stdcall.}
  vkCmdDrawMeshTasksIndirectNV*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}
  vkCmdDrawMeshTasksIndirectCountNV*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}
  vkCompileDeferredNV*: proc(device: VkDevice, pipeline: VkPipeline, shader: uint32): VkResult {.stdcall.}
  vkCreateAccelerationStructureNV*: proc(device: VkDevice, pCreateInfo: ptr VkAccelerationStructureCreateInfoNV , pAllocator: ptr VkAllocationCallbacks , pAccelerationStructure: ptr VkAccelerationStructureNV ): VkResult {.stdcall.}
  vkDestroyAccelerationStructureKHR*: proc(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetAccelerationStructureMemoryRequirementsKHR*: proc(device: VkDevice, pInfo: ptr VkAccelerationStructureMemoryRequirementsInfoKHR , pMemoryRequirements: ptr VkMemoryRequirements2 ): void {.stdcall.}
  vkGetAccelerationStructureMemoryRequirementsNV*: proc(device: VkDevice, pInfo: ptr VkAccelerationStructureMemoryRequirementsInfoNV , pMemoryRequirements: ptr VkMemoryRequirements2KHR ): void {.stdcall.}
  vkBindAccelerationStructureMemoryKHR*: proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindAccelerationStructureMemoryInfoKHR ): VkResult {.stdcall.}
  vkCmdCopyAccelerationStructureNV*: proc(commandBuffer: VkCommandBuffer, dst: VkAccelerationStructureKHR, src: VkAccelerationStructureKHR, mode: VkCopyAccelerationStructureModeKHR): void {.stdcall.}
  vkCmdCopyAccelerationStructureKHR*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyAccelerationStructureInfoKHR ): void {.stdcall.}
  vkCopyAccelerationStructureKHR*: proc(device: VkDevice, pInfo: ptr VkCopyAccelerationStructureInfoKHR ): VkResult {.stdcall.}
  vkCmdCopyAccelerationStructureToMemoryKHR*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyAccelerationStructureToMemoryInfoKHR ): void {.stdcall.}
  vkCopyAccelerationStructureToMemoryKHR*: proc(device: VkDevice, pInfo: ptr VkCopyAccelerationStructureToMemoryInfoKHR ): VkResult {.stdcall.}
  vkCmdCopyMemoryToAccelerationStructureKHR*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMemoryToAccelerationStructureInfoKHR ): void {.stdcall.}
  vkCopyMemoryToAccelerationStructureKHR*: proc(device: VkDevice, pInfo: ptr VkCopyMemoryToAccelerationStructureInfoKHR ): VkResult {.stdcall.}
  vkCmdWriteAccelerationStructuresPropertiesKHR*: proc(commandBuffer: VkCommandBuffer, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR , queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32): void {.stdcall.}
  vkCmdBuildAccelerationStructureNV*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkAccelerationStructureInfoNV , instanceData: VkBuffer, instanceOffset: VkDeviceSize, update: VkBool32, dst: VkAccelerationStructureKHR, src: VkAccelerationStructureKHR, scratch: VkBuffer, scratchOffset: VkDeviceSize): void {.stdcall.}
  vkWriteAccelerationStructuresPropertiesKHR*: proc(device: VkDevice, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR , queryType: VkQueryType, dataSize: uint, pData: pointer , stride: uint): VkResult {.stdcall.}
  vkCmdTraceRaysKHR*: proc(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: ptr VkStridedBufferRegionKHR , pMissShaderBindingTable: ptr VkStridedBufferRegionKHR , pHitShaderBindingTable: ptr VkStridedBufferRegionKHR , pCallableShaderBindingTable: ptr VkStridedBufferRegionKHR , width: uint32, height: uint32, depth: uint32): void {.stdcall.}
  vkCmdTraceRaysNV*: proc(commandBuffer: VkCommandBuffer, raygenShaderBindingTableBuffer: VkBuffer, raygenShaderBindingOffset: VkDeviceSize, missShaderBindingTableBuffer: VkBuffer, missShaderBindingOffset: VkDeviceSize, missShaderBindingStride: VkDeviceSize, hitShaderBindingTableBuffer: VkBuffer, hitShaderBindingOffset: VkDeviceSize, hitShaderBindingStride: VkDeviceSize, callableShaderBindingTableBuffer: VkBuffer, callableShaderBindingOffset: VkDeviceSize, callableShaderBindingStride: VkDeviceSize, width: uint32, height: uint32, depth: uint32): void {.stdcall.}
  vkGetRayTracingShaderGroupHandlesKHR*: proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: uint, pData: pointer ): VkResult {.stdcall.}
  vkGetRayTracingCaptureReplayShaderGroupHandlesKHR*: proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: uint, pData: pointer ): VkResult {.stdcall.}
  vkGetAccelerationStructureHandleNV*: proc(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, dataSize: uint, pData: pointer ): VkResult {.stdcall.}
  vkCreateRayTracingPipelinesNV*: proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkRayTracingPipelineCreateInfoNV , pAllocator: ptr VkAllocationCallbacks , pPipelines: ptr VkPipeline ): VkResult {.stdcall.}
  vkCreateRayTracingPipelinesKHR*: proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkRayTracingPipelineCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pPipelines: ptr VkPipeline ): VkResult {.stdcall.}
  vkGetPhysicalDeviceCooperativeMatrixPropertiesNV*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkCooperativeMatrixPropertiesNV ): VkResult {.stdcall.}
  vkCmdTraceRaysIndirectKHR*: proc(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: ptr VkStridedBufferRegionKHR , pMissShaderBindingTable: ptr VkStridedBufferRegionKHR , pHitShaderBindingTable: ptr VkStridedBufferRegionKHR , pCallableShaderBindingTable: ptr VkStridedBufferRegionKHR , buffer: VkBuffer, offset: VkDeviceSize): void {.stdcall.}
  vkGetDeviceAccelerationStructureCompatibilityKHR*: proc(device: VkDevice, version: ptr VkAccelerationStructureVersionKHR ): VkResult {.stdcall.}
  vkGetImageViewHandleNVX*: proc(device: VkDevice, pInfo: ptr VkImageViewHandleInfoNVX ): uint32 {.stdcall.}
  vkGetImageViewAddressNVX*: proc(device: VkDevice, imageView: VkImageView, pProperties: ptr VkImageViewAddressPropertiesNVX ): VkResult {.stdcall.}
  vkGetPhysicalDeviceSurfacePresentModes2EXT*: proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pPresentModeCount: ptr uint32 , pPresentModes: ptr VkPresentModeKHR ): VkResult {.stdcall.}
  vkGetDeviceGroupSurfacePresentModes2EXT*: proc(device: VkDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pModes: ptr VkDeviceGroupPresentModeFlagsKHR ): VkResult {.stdcall.}
  vkAcquireFullScreenExclusiveModeEXT*: proc(device: VkDevice, swapchain: VkSwapchainKHR): VkResult {.stdcall.}
  vkReleaseFullScreenExclusiveModeEXT*: proc(device: VkDevice, swapchain: VkSwapchainKHR): VkResult {.stdcall.}
  vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, pCounterCount: ptr uint32 , pCounters: ptr VkPerformanceCounterKHR , pCounterDescriptions: ptr VkPerformanceCounterDescriptionKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR*: proc(physicalDevice: VkPhysicalDevice, pPerformanceQueryCreateInfo: ptr VkQueryPoolPerformanceCreateInfoKHR , pNumPasses: ptr uint32 ): void {.stdcall.}
  vkAcquireProfilingLockKHR*: proc(device: VkDevice, pInfo: ptr VkAcquireProfilingLockInfoKHR ): VkResult {.stdcall.}
  vkReleaseProfilingLockKHR*: proc(device: VkDevice): void {.stdcall.}
  vkGetImageDrmFormatModifierPropertiesEXT*: proc(device: VkDevice, image: VkImage, pProperties: ptr VkImageDrmFormatModifierPropertiesEXT ): VkResult {.stdcall.}
  vkGetBufferOpaqueCaptureAddress*: proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo ): uint64 {.stdcall.}
  vkGetBufferDeviceAddress*: proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo ): VkDeviceAddress {.stdcall.}
  vkCreateHeadlessSurfaceEXT*: proc(instance: VkInstance, pCreateInfo: ptr VkHeadlessSurfaceCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV*: proc(physicalDevice: VkPhysicalDevice, pCombinationCount: ptr uint32 , pCombinations: ptr VkFramebufferMixedSamplesCombinationNV ): VkResult {.stdcall.}
  vkInitializePerformanceApiINTEL*: proc(device: VkDevice, pInitializeInfo: ptr VkInitializePerformanceApiInfoINTEL ): VkResult {.stdcall.}
  vkUninitializePerformanceApiINTEL*: proc(device: VkDevice): void {.stdcall.}
  vkCmdSetPerformanceMarkerINTEL*: proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkPerformanceMarkerInfoINTEL ): VkResult {.stdcall.}
  vkCmdSetPerformanceStreamMarkerINTEL*: proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkPerformanceStreamMarkerInfoINTEL ): VkResult {.stdcall.}
  vkCmdSetPerformanceOverrideINTEL*: proc(commandBuffer: VkCommandBuffer, pOverrideInfo: ptr VkPerformanceOverrideInfoINTEL ): VkResult {.stdcall.}
  vkAcquirePerformanceConfigurationINTEL*: proc(device: VkDevice, pAcquireInfo: ptr VkPerformanceConfigurationAcquireInfoINTEL , pConfiguration: ptr VkPerformanceConfigurationINTEL ): VkResult {.stdcall.}
  vkReleasePerformanceConfigurationINTEL*: proc(device: VkDevice, configuration: VkPerformanceConfigurationINTEL): VkResult {.stdcall.}
  vkQueueSetPerformanceConfigurationINTEL*: proc(queue: VkQueue, configuration: VkPerformanceConfigurationINTEL): VkResult {.stdcall.}
  vkGetPerformanceParameterINTEL*: proc(device: VkDevice, parameter: VkPerformanceParameterTypeINTEL, pValue: ptr VkPerformanceValueINTEL ): VkResult {.stdcall.}
  vkGetDeviceMemoryOpaqueCaptureAddress*: proc(device: VkDevice, pInfo: ptr VkDeviceMemoryOpaqueCaptureAddressInfo ): uint64 {.stdcall.}
  vkGetPipelineExecutablePropertiesKHR*: proc(device: VkDevice, pPipelineInfo: ptr VkPipelineInfoKHR        , pExecutableCount: ptr uint32 , pProperties: ptr VkPipelineExecutablePropertiesKHR ): VkResult {.stdcall.}
  vkGetPipelineExecutableStatisticsKHR*: proc(device: VkDevice, pExecutableInfo: ptr VkPipelineExecutableInfoKHR  , pStatisticCount: ptr uint32 , pStatistics: ptr VkPipelineExecutableStatisticKHR ): VkResult {.stdcall.}
  vkGetPipelineExecutableInternalRepresentationsKHR*: proc(device: VkDevice, pExecutableInfo: ptr VkPipelineExecutableInfoKHR  , pInternalRepresentationCount: ptr uint32 , pInternalRepresentations: ptr VkPipelineExecutableInternalRepresentationKHR ): VkResult {.stdcall.}
  vkCmdSetLineStippleEXT*: proc(commandBuffer: VkCommandBuffer, lineStippleFactor: uint32, lineStipplePattern: uint16): void {.stdcall.}
  vkGetPhysicalDeviceToolPropertiesEXT*: proc(physicalDevice: VkPhysicalDevice, pToolCount: ptr uint32 , pToolProperties: ptr VkPhysicalDeviceToolPropertiesEXT ): VkResult {.stdcall.}
  vkCreateAccelerationStructureKHR*: proc(device: VkDevice, pCreateInfo: ptr VkAccelerationStructureCreateInfoKHR        , pAllocator: ptr VkAllocationCallbacks       , pAccelerationStructure: ptr VkAccelerationStructureKHR                        ): VkResult {.stdcall.}
  vkCmdBuildAccelerationStructureKHR*: proc(commandBuffer: VkCommandBuffer, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR , ppOffsetInfos: ptr ptr VkAccelerationStructureBuildOffsetInfoKHR ): void {.stdcall.}
  vkCmdBuildAccelerationStructureIndirectKHR*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkAccelerationStructureBuildGeometryInfoKHR , indirectBuffer: VkBuffer, indirectOffset: VkDeviceSize, indirectStride: uint32): void {.stdcall.}
  vkBuildAccelerationStructureKHR*: proc(device: VkDevice, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR , ppOffsetInfos: ptr ptr VkAccelerationStructureBuildOffsetInfoKHR ): VkResult {.stdcall.}
  vkGetAccelerationStructureDeviceAddressKHR*: proc(device: VkDevice, pInfo: ptr VkAccelerationStructureDeviceAddressInfoKHR ): VkDeviceAddress {.stdcall.}
  vkCreateDeferredOperationKHR*: proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks , pDeferredOperation: ptr VkDeferredOperationKHR ): VkResult {.stdcall.}
  vkDestroyDeferredOperationKHR*: proc(device: VkDevice, operation: VkDeferredOperationKHR, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetDeferredOperationMaxConcurrencyKHR*: proc(device: VkDevice, operation: VkDeferredOperationKHR): uint32 {.stdcall.}
  vkGetDeferredOperationResultKHR*: proc(device: VkDevice, operation: VkDeferredOperationKHR): VkResult {.stdcall.}
  vkDeferredOperationJoinKHR*: proc(device: VkDevice, operation: VkDeferredOperationKHR): VkResult {.stdcall.}
  vkCmdSetCullModeEXT*: proc(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags): void {.stdcall.}
  vkCmdSetFrontFaceEXT*: proc(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace): void {.stdcall.}
  vkCmdSetPrimitiveTopologyEXT*: proc(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology): void {.stdcall.}
  vkCmdSetViewportWithCountEXT*: proc(commandBuffer: VkCommandBuffer, viewportCount: uint32, pViewports: ptr VkViewport ): void {.stdcall.}
  vkCmdSetScissorWithCountEXT*: proc(commandBuffer: VkCommandBuffer, scissorCount: uint32, pScissors: ptr VkRect2D ): void {.stdcall.}
  vkCmdBindVertexBuffers2EXT*: proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer , pOffsets: ptr VkDeviceSize , pSizes: ptr VkDeviceSize , pStrides: ptr VkDeviceSize ): void {.stdcall.}
  vkCmdSetDepthTestEnableEXT*: proc(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32): void {.stdcall.}
  vkCmdSetDepthWriteEnableEXT*: proc(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32): void {.stdcall.}
  vkCmdSetDepthCompareOpEXT*: proc(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp): void {.stdcall.}
  vkCmdSetDepthBoundsTestEnableEXT*: proc(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32): void {.stdcall.}
  vkCmdSetStencilTestEnableEXT*: proc(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32): void {.stdcall.}
  vkCmdSetStencilOpEXT*: proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp): void {.stdcall.}
  vkCreatePrivateDataSlotEXT*: proc(device: VkDevice, pCreateInfo: ptr VkPrivateDataSlotCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pPrivateDataSlot: ptr VkPrivateDataSlotEXT ): VkResult {.stdcall.}
  vkDestroyPrivateDataSlotEXT*: proc(device: VkDevice, privateDataSlot: VkPrivateDataSlotEXT, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkSetPrivateDataEXT*: proc(device: VkDevice, objectType: VkObjectType, objectHandle: uint64, privateDataSlot: VkPrivateDataSlotEXT, data: uint64): VkResult {.stdcall.}
  vkGetPrivateDataEXT*: proc(device: VkDevice, objectType: VkObjectType, objectHandle: uint64, privateDataSlot: VkPrivateDataSlotEXT, pData: ptr uint64 ): void {.stdcall.}

# Vulkan 1_0
proc vkLoad1_0*() =
  vkCreateInstance = cast[proc(pCreateInfo: ptr VkInstanceCreateInfo , pAllocator: ptr VkAllocationCallbacks , pInstance: ptr VkInstance ): VkResult {.stdcall.}](vkGetProc("vkCreateInstance"))
  vkDestroyInstance = cast[proc(instance: VkInstance, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyInstance"))
  vkEnumeratePhysicalDevices = cast[proc(instance: VkInstance, pPhysicalDeviceCount: ptr uint32 , pPhysicalDevices: ptr VkPhysicalDevice ): VkResult {.stdcall.}](vkGetProc("vkEnumeratePhysicalDevices"))
  vkGetPhysicalDeviceFeatures = cast[proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceFeatures"))
  vkGetPhysicalDeviceFormatProperties = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceFormatProperties"))
  vkGetPhysicalDeviceImageFormatProperties = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, `type`: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: ptr VkImageFormatProperties ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceImageFormatProperties"))
  vkGetPhysicalDeviceProperties = cast[proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceProperties"))
  vkGetPhysicalDeviceQueueFamilyProperties = cast[proc(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: ptr uint32 , pQueueFamilyProperties: ptr VkQueueFamilyProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceQueueFamilyProperties"))
  vkGetPhysicalDeviceMemoryProperties = cast[proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceMemoryProperties"))
  vkGetInstanceProcAddr = cast[proc(instance: VkInstance, pName: cstring ): PFN_vkVoidFunction {.stdcall.}](vkGetProc("vkGetInstanceProcAddr"))
  vkGetDeviceProcAddr = cast[proc(device: VkDevice, pName: cstring ): PFN_vkVoidFunction {.stdcall.}](vkGetProc("vkGetDeviceProcAddr"))
  vkCreateDevice = cast[proc(physicalDevice: VkPhysicalDevice, pCreateInfo: ptr VkDeviceCreateInfo , pAllocator: ptr VkAllocationCallbacks , pDevice: ptr VkDevice ): VkResult {.stdcall.}](vkGetProc("vkCreateDevice"))
  vkDestroyDevice = cast[proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyDevice"))
  vkEnumerateInstanceExtensionProperties = cast[proc(pLayerName: cstring , pPropertyCount: ptr uint32 , pProperties: ptr VkExtensionProperties ): VkResult {.stdcall.}](vkGetProc("vkEnumerateInstanceExtensionProperties"))
  vkEnumerateDeviceExtensionProperties = cast[proc(physicalDevice: VkPhysicalDevice, pLayerName: cstring , pPropertyCount: ptr uint32 , pProperties: ptr VkExtensionProperties ): VkResult {.stdcall.}](vkGetProc("vkEnumerateDeviceExtensionProperties"))
  vkEnumerateInstanceLayerProperties = cast[proc(pPropertyCount: ptr uint32 , pProperties: ptr VkLayerProperties ): VkResult {.stdcall.}](vkGetProc("vkEnumerateInstanceLayerProperties"))
  vkEnumerateDeviceLayerProperties = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkLayerProperties ): VkResult {.stdcall.}](vkGetProc("vkEnumerateDeviceLayerProperties"))
  vkGetDeviceQueue = cast[proc(device: VkDevice, queueFamilyIndex: uint32, queueIndex: uint32, pQueue: ptr VkQueue ): void {.stdcall.}](vkGetProc("vkGetDeviceQueue"))
  vkQueueSubmit = cast[proc(queue: VkQueue, submitCount: uint32, pSubmits: ptr VkSubmitInfo , fence: VkFence): VkResult {.stdcall.}](vkGetProc("vkQueueSubmit"))
  vkQueueWaitIdle = cast[proc(queue: VkQueue): VkResult {.stdcall.}](vkGetProc("vkQueueWaitIdle"))
  vkDeviceWaitIdle = cast[proc(device: VkDevice): VkResult {.stdcall.}](vkGetProc("vkDeviceWaitIdle"))
  vkAllocateMemory = cast[proc(device: VkDevice, pAllocateInfo: ptr VkMemoryAllocateInfo , pAllocator: ptr VkAllocationCallbacks , pMemory: ptr VkDeviceMemory ): VkResult {.stdcall.}](vkGetProc("vkAllocateMemory"))
  vkFreeMemory = cast[proc(device: VkDevice, memory: VkDeviceMemory, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkFreeMemory"))
  vkMapMemory = cast[proc(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: ptr pointer ): VkResult {.stdcall.}](vkGetProc("vkMapMemory"))
  vkUnmapMemory = cast[proc(device: VkDevice, memory: VkDeviceMemory): void {.stdcall.}](vkGetProc("vkUnmapMemory"))
  vkFlushMappedMemoryRanges = cast[proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange ): VkResult {.stdcall.}](vkGetProc("vkFlushMappedMemoryRanges"))
  vkInvalidateMappedMemoryRanges = cast[proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange ): VkResult {.stdcall.}](vkGetProc("vkInvalidateMappedMemoryRanges"))
  vkGetDeviceMemoryCommitment = cast[proc(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: ptr VkDeviceSize ): void {.stdcall.}](vkGetProc("vkGetDeviceMemoryCommitment"))
  vkBindBufferMemory = cast[proc(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.}](vkGetProc("vkBindBufferMemory"))
  vkBindImageMemory = cast[proc(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.}](vkGetProc("vkBindImageMemory"))
  vkGetBufferMemoryRequirements = cast[proc(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: ptr VkMemoryRequirements ): void {.stdcall.}](vkGetProc("vkGetBufferMemoryRequirements"))
  vkGetImageMemoryRequirements = cast[proc(device: VkDevice, image: VkImage, pMemoryRequirements: ptr VkMemoryRequirements ): void {.stdcall.}](vkGetProc("vkGetImageMemoryRequirements"))
  vkGetImageSparseMemoryRequirements = cast[proc(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: ptr uint32 , pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements ): void {.stdcall.}](vkGetProc("vkGetImageSparseMemoryRequirements"))
  vkGetPhysicalDeviceSparseImageFormatProperties = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, `type`: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: ptr uint32 , pProperties: ptr VkSparseImageFormatProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSparseImageFormatProperties"))
  vkQueueBindSparse = cast[proc(queue: VkQueue, bindInfoCount: uint32, pBindInfo: ptr VkBindSparseInfo , fence: VkFence): VkResult {.stdcall.}](vkGetProc("vkQueueBindSparse"))
  vkCreateFence = cast[proc(device: VkDevice, pCreateInfo: ptr VkFenceCreateInfo , pAllocator: ptr VkAllocationCallbacks , pFence: ptr VkFence ): VkResult {.stdcall.}](vkGetProc("vkCreateFence"))
  vkDestroyFence = cast[proc(device: VkDevice, fence: VkFence, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyFence"))
  vkResetFences = cast[proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence ): VkResult {.stdcall.}](vkGetProc("vkResetFences"))
  vkGetFenceStatus = cast[proc(device: VkDevice, fence: VkFence): VkResult {.stdcall.}](vkGetProc("vkGetFenceStatus"))
  vkWaitForFences = cast[proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence , waitAll: VkBool32, timeout: uint64): VkResult {.stdcall.}](vkGetProc("vkWaitForFences"))
  vkCreateSemaphore = cast[proc(device: VkDevice, pCreateInfo: ptr VkSemaphoreCreateInfo , pAllocator: ptr VkAllocationCallbacks , pSemaphore: ptr VkSemaphore ): VkResult {.stdcall.}](vkGetProc("vkCreateSemaphore"))
  vkDestroySemaphore = cast[proc(device: VkDevice, semaphore: VkSemaphore, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroySemaphore"))
  vkCreateEvent = cast[proc(device: VkDevice, pCreateInfo: ptr VkEventCreateInfo , pAllocator: ptr VkAllocationCallbacks , pEvent: ptr VkEvent ): VkResult {.stdcall.}](vkGetProc("vkCreateEvent"))
  vkDestroyEvent = cast[proc(device: VkDevice, event: VkEvent, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyEvent"))
  vkGetEventStatus = cast[proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}](vkGetProc("vkGetEventStatus"))
  vkSetEvent = cast[proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}](vkGetProc("vkSetEvent"))
  vkResetEvent = cast[proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}](vkGetProc("vkResetEvent"))
  vkCreateQueryPool = cast[proc(device: VkDevice, pCreateInfo: ptr VkQueryPoolCreateInfo , pAllocator: ptr VkAllocationCallbacks , pQueryPool: ptr VkQueryPool ): VkResult {.stdcall.}](vkGetProc("vkCreateQueryPool"))
  vkDestroyQueryPool = cast[proc(device: VkDevice, queryPool: VkQueryPool, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyQueryPool"))
  vkGetQueryPoolResults = cast[proc(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32, dataSize: uint, pData: pointer , stride: VkDeviceSize, flags: VkQueryResultFlags): VkResult {.stdcall.}](vkGetProc("vkGetQueryPoolResults"))
  vkCreateBuffer = cast[proc(device: VkDevice, pCreateInfo: ptr VkBufferCreateInfo , pAllocator: ptr VkAllocationCallbacks , pBuffer: ptr VkBuffer ): VkResult {.stdcall.}](vkGetProc("vkCreateBuffer"))
  vkDestroyBuffer = cast[proc(device: VkDevice, buffer: VkBuffer, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyBuffer"))
  vkCreateBufferView = cast[proc(device: VkDevice, pCreateInfo: ptr VkBufferViewCreateInfo , pAllocator: ptr VkAllocationCallbacks , pView: ptr VkBufferView ): VkResult {.stdcall.}](vkGetProc("vkCreateBufferView"))
  vkDestroyBufferView = cast[proc(device: VkDevice, bufferView: VkBufferView, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyBufferView"))
  vkCreateImage = cast[proc(device: VkDevice, pCreateInfo: ptr VkImageCreateInfo , pAllocator: ptr VkAllocationCallbacks , pImage: ptr VkImage ): VkResult {.stdcall.}](vkGetProc("vkCreateImage"))
  vkDestroyImage = cast[proc(device: VkDevice, image: VkImage, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyImage"))
  vkGetImageSubresourceLayout = cast[proc(device: VkDevice, image: VkImage, pSubresource: ptr VkImageSubresource , pLayout: ptr VkSubresourceLayout ): void {.stdcall.}](vkGetProc("vkGetImageSubresourceLayout"))
  vkCreateImageView = cast[proc(device: VkDevice, pCreateInfo: ptr VkImageViewCreateInfo , pAllocator: ptr VkAllocationCallbacks , pView: ptr VkImageView ): VkResult {.stdcall.}](vkGetProc("vkCreateImageView"))
  vkDestroyImageView = cast[proc(device: VkDevice, imageView: VkImageView, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyImageView"))
  vkCreateShaderModule = cast[proc(device: VkDevice, pCreateInfo: ptr VkShaderModuleCreateInfo , pAllocator: ptr VkAllocationCallbacks , pShaderModule: ptr VkShaderModule ): VkResult {.stdcall.}](vkGetProc("vkCreateShaderModule"))
  vkDestroyShaderModule = cast[proc(device: VkDevice, shaderModule: VkShaderModule, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyShaderModule"))
  vkCreatePipelineCache = cast[proc(device: VkDevice, pCreateInfo: ptr VkPipelineCacheCreateInfo , pAllocator: ptr VkAllocationCallbacks , pPipelineCache: ptr VkPipelineCache ): VkResult {.stdcall.}](vkGetProc("vkCreatePipelineCache"))
  vkDestroyPipelineCache = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyPipelineCache"))
  vkGetPipelineCacheData = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: ptr uint , pData: pointer ): VkResult {.stdcall.}](vkGetProc("vkGetPipelineCacheData"))
  vkMergePipelineCaches = cast[proc(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: uint32, pSrcCaches: ptr VkPipelineCache ): VkResult {.stdcall.}](vkGetProc("vkMergePipelineCaches"))
  vkCreateGraphicsPipelines = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkGraphicsPipelineCreateInfo , pAllocator: ptr VkAllocationCallbacks , pPipelines: ptr VkPipeline ): VkResult {.stdcall.}](vkGetProc("vkCreateGraphicsPipelines"))
  vkCreateComputePipelines = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkComputePipelineCreateInfo , pAllocator: ptr VkAllocationCallbacks , pPipelines: ptr VkPipeline ): VkResult {.stdcall.}](vkGetProc("vkCreateComputePipelines"))
  vkDestroyPipeline = cast[proc(device: VkDevice, pipeline: VkPipeline, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyPipeline"))
  vkCreatePipelineLayout = cast[proc(device: VkDevice, pCreateInfo: ptr VkPipelineLayoutCreateInfo , pAllocator: ptr VkAllocationCallbacks , pPipelineLayout: ptr VkPipelineLayout ): VkResult {.stdcall.}](vkGetProc("vkCreatePipelineLayout"))
  vkDestroyPipelineLayout = cast[proc(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyPipelineLayout"))
  vkCreateSampler = cast[proc(device: VkDevice, pCreateInfo: ptr VkSamplerCreateInfo , pAllocator: ptr VkAllocationCallbacks , pSampler: ptr VkSampler ): VkResult {.stdcall.}](vkGetProc("vkCreateSampler"))
  vkDestroySampler = cast[proc(device: VkDevice, sampler: VkSampler, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroySampler"))
  vkCreateDescriptorSetLayout = cast[proc(device: VkDevice, pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo , pAllocator: ptr VkAllocationCallbacks , pSetLayout: ptr VkDescriptorSetLayout ): VkResult {.stdcall.}](vkGetProc("vkCreateDescriptorSetLayout"))
  vkDestroyDescriptorSetLayout = cast[proc(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyDescriptorSetLayout"))
  vkCreateDescriptorPool = cast[proc(device: VkDevice, pCreateInfo: ptr VkDescriptorPoolCreateInfo , pAllocator: ptr VkAllocationCallbacks , pDescriptorPool: ptr VkDescriptorPool ): VkResult {.stdcall.}](vkGetProc("vkCreateDescriptorPool"))
  vkDestroyDescriptorPool = cast[proc(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyDescriptorPool"))
  vkResetDescriptorPool = cast[proc(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags): VkResult {.stdcall.}](vkGetProc("vkResetDescriptorPool"))
  vkAllocateDescriptorSets = cast[proc(device: VkDevice, pAllocateInfo: ptr VkDescriptorSetAllocateInfo , pDescriptorSets: ptr VkDescriptorSet ): VkResult {.stdcall.}](vkGetProc("vkAllocateDescriptorSets"))
  vkFreeDescriptorSets = cast[proc(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: uint32, pDescriptorSets: ptr VkDescriptorSet ): VkResult {.stdcall.}](vkGetProc("vkFreeDescriptorSets"))
  vkUpdateDescriptorSets = cast[proc(device: VkDevice, descriptorWriteCount: uint32, pDescriptorWrites: ptr VkWriteDescriptorSet , descriptorCopyCount: uint32, pDescriptorCopies: ptr VkCopyDescriptorSet ): void {.stdcall.}](vkGetProc("vkUpdateDescriptorSets"))
  vkCreateFramebuffer = cast[proc(device: VkDevice, pCreateInfo: ptr VkFramebufferCreateInfo , pAllocator: ptr VkAllocationCallbacks , pFramebuffer: ptr VkFramebuffer ): VkResult {.stdcall.}](vkGetProc("vkCreateFramebuffer"))
  vkDestroyFramebuffer = cast[proc(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyFramebuffer"))
  vkCreateRenderPass = cast[proc(device: VkDevice, pCreateInfo: ptr VkRenderPassCreateInfo , pAllocator: ptr VkAllocationCallbacks , pRenderPass: ptr VkRenderPass ): VkResult {.stdcall.}](vkGetProc("vkCreateRenderPass"))
  vkDestroyRenderPass = cast[proc(device: VkDevice, renderPass: VkRenderPass, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyRenderPass"))
  vkGetRenderAreaGranularity = cast[proc(device: VkDevice, renderPass: VkRenderPass, pGranularity: ptr VkExtent2D ): void {.stdcall.}](vkGetProc("vkGetRenderAreaGranularity"))
  vkCreateCommandPool = cast[proc(device: VkDevice, pCreateInfo: ptr VkCommandPoolCreateInfo , pAllocator: ptr VkAllocationCallbacks , pCommandPool: ptr VkCommandPool ): VkResult {.stdcall.}](vkGetProc("vkCreateCommandPool"))
  vkDestroyCommandPool = cast[proc(device: VkDevice, commandPool: VkCommandPool, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyCommandPool"))
  vkResetCommandPool = cast[proc(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags): VkResult {.stdcall.}](vkGetProc("vkResetCommandPool"))
  vkAllocateCommandBuffers = cast[proc(device: VkDevice, pAllocateInfo: ptr VkCommandBufferAllocateInfo , pCommandBuffers: ptr VkCommandBuffer ): VkResult {.stdcall.}](vkGetProc("vkAllocateCommandBuffers"))
  vkFreeCommandBuffers = cast[proc(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer ): void {.stdcall.}](vkGetProc("vkFreeCommandBuffers"))
  vkBeginCommandBuffer = cast[proc(commandBuffer: VkCommandBuffer, pBeginInfo: ptr VkCommandBufferBeginInfo ): VkResult {.stdcall.}](vkGetProc("vkBeginCommandBuffer"))
  vkEndCommandBuffer = cast[proc(commandBuffer: VkCommandBuffer): VkResult {.stdcall.}](vkGetProc("vkEndCommandBuffer"))
  vkResetCommandBuffer = cast[proc(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags): VkResult {.stdcall.}](vkGetProc("vkResetCommandBuffer"))
  vkCmdBindPipeline = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline): void {.stdcall.}](vkGetProc("vkCmdBindPipeline"))
  vkCmdSetViewport = cast[proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewports: ptr VkViewport ): void {.stdcall.}](vkGetProc("vkCmdSetViewport"))
  vkCmdSetScissor = cast[proc(commandBuffer: VkCommandBuffer, firstScissor: uint32, scissorCount: uint32, pScissors: ptr VkRect2D ): void {.stdcall.}](vkGetProc("vkCmdSetScissor"))
  vkCmdSetLineWidth = cast[proc(commandBuffer: VkCommandBuffer, lineWidth: float32): void {.stdcall.}](vkGetProc("vkCmdSetLineWidth"))
  vkCmdSetDepthBias = cast[proc(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: float32, depthBiasClamp: float32, depthBiasSlopeFactor: float32): void {.stdcall.}](vkGetProc("vkCmdSetDepthBias"))
  vkCmdSetBlendConstants = cast[proc(commandBuffer: VkCommandBuffer, blendConstants: array[4, float32]): void {.stdcall.}](vkGetProc("vkCmdSetBlendConstants"))
  vkCmdSetDepthBounds = cast[proc(commandBuffer: VkCommandBuffer, minDepthBounds: float32, maxDepthBounds: float32): void {.stdcall.}](vkGetProc("vkCmdSetDepthBounds"))
  vkCmdSetStencilCompareMask = cast[proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: uint32): void {.stdcall.}](vkGetProc("vkCmdSetStencilCompareMask"))
  vkCmdSetStencilWriteMask = cast[proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: uint32): void {.stdcall.}](vkGetProc("vkCmdSetStencilWriteMask"))
  vkCmdSetStencilReference = cast[proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: uint32): void {.stdcall.}](vkGetProc("vkCmdSetStencilReference"))
  vkCmdBindDescriptorSets = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: uint32, descriptorSetCount: uint32, pDescriptorSets: ptr VkDescriptorSet , dynamicOffsetCount: uint32, pDynamicOffsets: ptr uint32 ): void {.stdcall.}](vkGetProc("vkCmdBindDescriptorSets"))
  vkCmdBindIndexBuffer = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType): void {.stdcall.}](vkGetProc("vkCmdBindIndexBuffer"))
  vkCmdBindVertexBuffers = cast[proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer , pOffsets: ptr VkDeviceSize ): void {.stdcall.}](vkGetProc("vkCmdBindVertexBuffers"))
  vkCmdDraw = cast[proc(commandBuffer: VkCommandBuffer, vertexCount: uint32, instanceCount: uint32, firstVertex: uint32, firstInstance: uint32): void {.stdcall.}](vkGetProc("vkCmdDraw"))
  vkCmdDrawIndexed = cast[proc(commandBuffer: VkCommandBuffer, indexCount: uint32, instanceCount: uint32, firstIndex: uint32, vertexOffset: int32, firstInstance: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawIndexed"))
  vkCmdDrawIndirect = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawIndirect"))
  vkCmdDrawIndexedIndirect = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawIndexedIndirect"))
  vkCmdDispatch = cast[proc(commandBuffer: VkCommandBuffer, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}](vkGetProc("vkCmdDispatch"))
  vkCmdDispatchIndirect = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize): void {.stdcall.}](vkGetProc("vkCmdDispatchIndirect"))
  vkCmdCopyBuffer = cast[proc(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: uint32, pRegions: ptr VkBufferCopy ): void {.stdcall.}](vkGetProc("vkCmdCopyBuffer"))
  vkCmdCopyImage = cast[proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageCopy ): void {.stdcall.}](vkGetProc("vkCmdCopyImage"))
  vkCmdBlitImage = cast[proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageBlit , filter: VkFilter): void {.stdcall.}](vkGetProc("vkCmdBlitImage"))
  vkCmdCopyBufferToImage = cast[proc(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkBufferImageCopy ): void {.stdcall.}](vkGetProc("vkCmdCopyBufferToImage"))
  vkCmdCopyImageToBuffer = cast[proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: uint32, pRegions: ptr VkBufferImageCopy ): void {.stdcall.}](vkGetProc("vkCmdCopyImageToBuffer"))
  vkCmdUpdateBuffer = cast[proc(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: pointer ): void {.stdcall.}](vkGetProc("vkCmdUpdateBuffer"))
  vkCmdFillBuffer = cast[proc(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: uint32): void {.stdcall.}](vkGetProc("vkCmdFillBuffer"))
  vkCmdClearColorImage = cast[proc(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: ptr VkClearColorValue , rangeCount: uint32, pRanges: ptr VkImageSubresourceRange ): void {.stdcall.}](vkGetProc("vkCmdClearColorImage"))
  vkCmdClearDepthStencilImage = cast[proc(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: ptr VkClearDepthStencilValue , rangeCount: uint32, pRanges: ptr VkImageSubresourceRange ): void {.stdcall.}](vkGetProc("vkCmdClearDepthStencilImage"))
  vkCmdClearAttachments = cast[proc(commandBuffer: VkCommandBuffer, attachmentCount: uint32, pAttachments: ptr VkClearAttachment , rectCount: uint32, pRects: ptr VkClearRect ): void {.stdcall.}](vkGetProc("vkCmdClearAttachments"))
  vkCmdResolveImage = cast[proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageResolve ): void {.stdcall.}](vkGetProc("vkCmdResolveImage"))
  vkCmdSetEvent = cast[proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags): void {.stdcall.}](vkGetProc("vkCmdSetEvent"))
  vkCmdResetEvent = cast[proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags): void {.stdcall.}](vkGetProc("vkCmdResetEvent"))
  vkCmdWaitEvents = cast[proc(commandBuffer: VkCommandBuffer, eventCount: uint32, pEvents: ptr VkEvent , srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, memoryBarrierCount: uint32, pMemoryBarriers: ptr VkMemoryBarrier , bufferMemoryBarrierCount: uint32, pBufferMemoryBarriers: ptr VkBufferMemoryBarrier , imageMemoryBarrierCount: uint32, pImageMemoryBarriers: ptr VkImageMemoryBarrier ): void {.stdcall.}](vkGetProc("vkCmdWaitEvents"))
  vkCmdPipelineBarrier = cast[proc(commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: uint32, pMemoryBarriers: ptr VkMemoryBarrier , bufferMemoryBarrierCount: uint32, pBufferMemoryBarriers: ptr VkBufferMemoryBarrier , imageMemoryBarrierCount: uint32, pImageMemoryBarriers: ptr VkImageMemoryBarrier ): void {.stdcall.}](vkGetProc("vkCmdPipelineBarrier"))
  vkCmdBeginQuery = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, flags: VkQueryControlFlags): void {.stdcall.}](vkGetProc("vkCmdBeginQuery"))
  vkCmdEndQuery = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32): void {.stdcall.}](vkGetProc("vkCmdEndQuery"))
  vkCmdResetQueryPool = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32): void {.stdcall.}](vkGetProc("vkCmdResetQueryPool"))
  vkCmdWriteTimestamp = cast[proc(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, queryPool: VkQueryPool, query: uint32): void {.stdcall.}](vkGetProc("vkCmdWriteTimestamp"))
  vkCmdCopyQueryPoolResults = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags): void {.stdcall.}](vkGetProc("vkCmdCopyQueryPoolResults"))
  vkCmdPushConstants = cast[proc(commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: uint32, size: uint32, pValues: pointer ): void {.stdcall.}](vkGetProc("vkCmdPushConstants"))
  vkCmdBeginRenderPass = cast[proc(commandBuffer: VkCommandBuffer, pRenderPassBegin: ptr VkRenderPassBeginInfo , contents: VkSubpassContents): void {.stdcall.}](vkGetProc("vkCmdBeginRenderPass"))
  vkCmdNextSubpass = cast[proc(commandBuffer: VkCommandBuffer, contents: VkSubpassContents): void {.stdcall.}](vkGetProc("vkCmdNextSubpass"))
  vkCmdEndRenderPass = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetProc("vkCmdEndRenderPass"))
  vkCmdExecuteCommands = cast[proc(commandBuffer: VkCommandBuffer, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer ): void {.stdcall.}](vkGetProc("vkCmdExecuteCommands"))

# Vulkan 1_1
proc vkLoad1_1*() =
  vkEnumerateInstanceVersion = cast[proc(pApiVersion: ptr uint32 ): VkResult {.stdcall.}](vkGetProc("vkEnumerateInstanceVersion"))
  vkBindBufferMemory2 = cast[proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindBufferMemoryInfo ): VkResult {.stdcall.}](vkGetProc("vkBindBufferMemory2"))
  vkBindImageMemory2 = cast[proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindImageMemoryInfo ): VkResult {.stdcall.}](vkGetProc("vkBindImageMemory2"))
  vkGetDeviceGroupPeerMemoryFeatures = cast[proc(device: VkDevice, heapIndex: uint32, localDeviceIndex: uint32, remoteDeviceIndex: uint32, pPeerMemoryFeatures: ptr VkPeerMemoryFeatureFlags ): void {.stdcall.}](vkGetProc("vkGetDeviceGroupPeerMemoryFeatures"))
  vkCmdSetDeviceMask = cast[proc(commandBuffer: VkCommandBuffer, deviceMask: uint32): void {.stdcall.}](vkGetProc("vkCmdSetDeviceMask"))
  vkCmdDispatchBase = cast[proc(commandBuffer: VkCommandBuffer, baseGroupX: uint32, baseGroupY: uint32, baseGroupZ: uint32, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}](vkGetProc("vkCmdDispatchBase"))
  vkEnumeratePhysicalDeviceGroups = cast[proc(instance: VkInstance, pPhysicalDeviceGroupCount: ptr uint32 , pPhysicalDeviceGroupProperties: ptr VkPhysicalDeviceGroupProperties ): VkResult {.stdcall.}](vkGetProc("vkEnumeratePhysicalDeviceGroups"))
  vkGetImageMemoryRequirements2 = cast[proc(device: VkDevice, pInfo: ptr VkImageMemoryRequirementsInfo2 , pMemoryRequirements: ptr VkMemoryRequirements2 ): void {.stdcall.}](vkGetProc("vkGetImageMemoryRequirements2"))
  vkGetBufferMemoryRequirements2 = cast[proc(device: VkDevice, pInfo: ptr VkBufferMemoryRequirementsInfo2 , pMemoryRequirements: ptr VkMemoryRequirements2 ): void {.stdcall.}](vkGetProc("vkGetBufferMemoryRequirements2"))
  vkGetImageSparseMemoryRequirements2 = cast[proc(device: VkDevice, pInfo: ptr VkImageSparseMemoryRequirementsInfo2 , pSparseMemoryRequirementCount: ptr uint32 , pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements2 ): void {.stdcall.}](vkGetProc("vkGetImageSparseMemoryRequirements2"))
  vkGetPhysicalDeviceFeatures2 = cast[proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures2 ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceFeatures2"))
  vkGetPhysicalDeviceProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties2 ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceProperties2"))
  vkGetPhysicalDeviceFormatProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties2 ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceFormatProperties2"))
  vkGetPhysicalDeviceImageFormatProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pImageFormatInfo: ptr VkPhysicalDeviceImageFormatInfo2 , pImageFormatProperties: ptr VkImageFormatProperties2 ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceImageFormatProperties2"))
  vkGetPhysicalDeviceQueueFamilyProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: ptr uint32 , pQueueFamilyProperties: ptr VkQueueFamilyProperties2 ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceQueueFamilyProperties2"))
  vkGetPhysicalDeviceMemoryProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties2 ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceMemoryProperties2"))
  vkGetPhysicalDeviceSparseImageFormatProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pFormatInfo: ptr VkPhysicalDeviceSparseImageFormatInfo2 , pPropertyCount: ptr uint32 , pProperties: ptr VkSparseImageFormatProperties2 ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSparseImageFormatProperties2"))
  vkTrimCommandPool = cast[proc(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags): void {.stdcall.}](vkGetProc("vkTrimCommandPool"))
  vkGetDeviceQueue2 = cast[proc(device: VkDevice, pQueueInfo: ptr VkDeviceQueueInfo2 , pQueue: ptr VkQueue ): void {.stdcall.}](vkGetProc("vkGetDeviceQueue2"))
  vkCreateSamplerYcbcrConversion = cast[proc(device: VkDevice, pCreateInfo: ptr VkSamplerYcbcrConversionCreateInfo , pAllocator: ptr VkAllocationCallbacks , pYcbcrConversion: ptr VkSamplerYcbcrConversion ): VkResult {.stdcall.}](vkGetProc("vkCreateSamplerYcbcrConversion"))
  vkDestroySamplerYcbcrConversion = cast[proc(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroySamplerYcbcrConversion"))
  vkCreateDescriptorUpdateTemplate = cast[proc(device: VkDevice, pCreateInfo: ptr VkDescriptorUpdateTemplateCreateInfo , pAllocator: ptr VkAllocationCallbacks , pDescriptorUpdateTemplate: ptr VkDescriptorUpdateTemplate ): VkResult {.stdcall.}](vkGetProc("vkCreateDescriptorUpdateTemplate"))
  vkDestroyDescriptorUpdateTemplate = cast[proc(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyDescriptorUpdateTemplate"))
  vkUpdateDescriptorSetWithTemplate = cast[proc(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: pointer ): void {.stdcall.}](vkGetProc("vkUpdateDescriptorSetWithTemplate"))
  vkGetPhysicalDeviceExternalBufferProperties = cast[proc(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: ptr VkPhysicalDeviceExternalBufferInfo , pExternalBufferProperties: ptr VkExternalBufferProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceExternalBufferProperties"))
  vkGetPhysicalDeviceExternalFenceProperties = cast[proc(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: ptr VkPhysicalDeviceExternalFenceInfo , pExternalFenceProperties: ptr VkExternalFenceProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceExternalFenceProperties"))
  vkGetPhysicalDeviceExternalSemaphoreProperties = cast[proc(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: ptr VkPhysicalDeviceExternalSemaphoreInfo , pExternalSemaphoreProperties: ptr VkExternalSemaphoreProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceExternalSemaphoreProperties"))
  vkGetDescriptorSetLayoutSupport = cast[proc(device: VkDevice, pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo , pSupport: ptr VkDescriptorSetLayoutSupport ): void {.stdcall.}](vkGetProc("vkGetDescriptorSetLayoutSupport"))

# Vulkan 1_2
proc vkLoad1_2*() =
  vkCmdDrawIndirectCount = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawIndirectCount"))
  vkCmdDrawIndexedIndirectCount = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawIndexedIndirectCount"))
  vkCreateRenderPass2 = cast[proc(device: VkDevice, pCreateInfo: ptr VkRenderPassCreateInfo2 , pAllocator: ptr VkAllocationCallbacks , pRenderPass: ptr VkRenderPass ): VkResult {.stdcall.}](vkGetProc("vkCreateRenderPass2"))
  vkCmdBeginRenderPass2 = cast[proc(commandBuffer: VkCommandBuffer, pRenderPassBegin: ptr VkRenderPassBeginInfo      , pSubpassBeginInfo: ptr VkSubpassBeginInfo      ): void {.stdcall.}](vkGetProc("vkCmdBeginRenderPass2"))
  vkCmdNextSubpass2 = cast[proc(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: ptr VkSubpassBeginInfo      , pSubpassEndInfo: ptr VkSubpassEndInfo        ): void {.stdcall.}](vkGetProc("vkCmdNextSubpass2"))
  vkCmdEndRenderPass2 = cast[proc(commandBuffer: VkCommandBuffer, pSubpassEndInfo: ptr VkSubpassEndInfo        ): void {.stdcall.}](vkGetProc("vkCmdEndRenderPass2"))
  vkResetQueryPool = cast[proc(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32): void {.stdcall.}](vkGetProc("vkResetQueryPool"))
  vkGetSemaphoreCounterValue = cast[proc(device: VkDevice, semaphore: VkSemaphore, pValue: ptr uint64 ): VkResult {.stdcall.}](vkGetProc("vkGetSemaphoreCounterValue"))
  vkWaitSemaphores = cast[proc(device: VkDevice, pWaitInfo: ptr VkSemaphoreWaitInfo , timeout: uint64): VkResult {.stdcall.}](vkGetProc("vkWaitSemaphores"))
  vkSignalSemaphore = cast[proc(device: VkDevice, pSignalInfo: ptr VkSemaphoreSignalInfo ): VkResult {.stdcall.}](vkGetProc("vkSignalSemaphore"))
  vkGetBufferDeviceAddress = cast[proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo ): VkDeviceAddress {.stdcall.}](vkGetProc("vkGetBufferDeviceAddress"))
  vkGetBufferOpaqueCaptureAddress = cast[proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo ): uint64 {.stdcall.}](vkGetProc("vkGetBufferOpaqueCaptureAddress"))
  vkGetDeviceMemoryOpaqueCaptureAddress = cast[proc(device: VkDevice, pInfo: ptr VkDeviceMemoryOpaqueCaptureAddressInfo ): uint64 {.stdcall.}](vkGetProc("vkGetDeviceMemoryOpaqueCaptureAddress"))

# Load VK_KHR_surface
proc loadVK_KHR_surface*() =
  vkDestroySurfaceKHR = cast[proc(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroySurfaceKHR"))
  vkGetPhysicalDeviceSurfaceSupportKHR = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, surface: VkSurfaceKHR, pSupported: ptr VkBool32 ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSurfaceSupportKHR"))
  vkGetPhysicalDeviceSurfaceCapabilitiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: ptr VkSurfaceCapabilitiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSurfaceCapabilitiesKHR"))
  vkGetPhysicalDeviceSurfaceFormatsKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: ptr uint32 , pSurfaceFormats: ptr VkSurfaceFormatKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSurfaceFormatsKHR"))
  vkGetPhysicalDeviceSurfacePresentModesKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: ptr uint32 , pPresentModes: ptr VkPresentModeKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSurfacePresentModesKHR"))

# Load VK_KHR_swapchain
proc loadVK_KHR_swapchain*() =
  vkCreateSwapchainKHR = cast[proc(device: VkDevice, pCreateInfo: ptr VkSwapchainCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSwapchain: ptr VkSwapchainKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateSwapchainKHR"))
  vkDestroySwapchainKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroySwapchainKHR"))
  vkGetSwapchainImagesKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: ptr uint32 , pSwapchainImages: ptr VkImage ): VkResult {.stdcall.}](vkGetProc("vkGetSwapchainImagesKHR"))
  vkAcquireNextImageKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, timeout: uint64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: ptr uint32 ): VkResult {.stdcall.}](vkGetProc("vkAcquireNextImageKHR"))
  vkQueuePresentKHR = cast[proc(queue: VkQueue, pPresentInfo: ptr VkPresentInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkQueuePresentKHR"))
  vkGetDeviceGroupPresentCapabilitiesKHR = cast[proc(device: VkDevice, pDeviceGroupPresentCapabilities: ptr VkDeviceGroupPresentCapabilitiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDeviceGroupPresentCapabilitiesKHR"))
  vkGetDeviceGroupSurfacePresentModesKHR = cast[proc(device: VkDevice, surface: VkSurfaceKHR, pModes: ptr VkDeviceGroupPresentModeFlagsKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDeviceGroupSurfacePresentModesKHR"))
  vkGetPhysicalDevicePresentRectanglesKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: ptr uint32 , pRects: ptr VkRect2D ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDevicePresentRectanglesKHR"))
  vkAcquireNextImage2KHR = cast[proc(device: VkDevice, pAcquireInfo: ptr VkAcquireNextImageInfoKHR , pImageIndex: ptr uint32 ): VkResult {.stdcall.}](vkGetProc("vkAcquireNextImage2KHR"))

# Load VK_KHR_display
proc loadVK_KHR_display*() =
  vkGetPhysicalDeviceDisplayPropertiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayPropertiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceDisplayPropertiesKHR"))
  vkGetPhysicalDeviceDisplayPlanePropertiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayPlanePropertiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceDisplayPlanePropertiesKHR"))
  vkGetDisplayPlaneSupportedDisplaysKHR = cast[proc(physicalDevice: VkPhysicalDevice, planeIndex: uint32, pDisplayCount: ptr uint32 , pDisplays: ptr VkDisplayKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDisplayPlaneSupportedDisplaysKHR"))
  vkGetDisplayModePropertiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayModePropertiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDisplayModePropertiesKHR"))
  vkCreateDisplayModeKHR = cast[proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: ptr VkDisplayModeCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pMode: ptr VkDisplayModeKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateDisplayModeKHR"))
  vkGetDisplayPlaneCapabilitiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: uint32, pCapabilities: ptr VkDisplayPlaneCapabilitiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDisplayPlaneCapabilitiesKHR"))
  vkCreateDisplayPlaneSurfaceKHR = cast[proc(instance: VkInstance, pCreateInfo: ptr VkDisplaySurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateDisplayPlaneSurfaceKHR"))

# Load VK_KHR_display_swapchain
proc loadVK_KHR_display_swapchain*() =
  vkCreateSharedSwapchainsKHR = cast[proc(device: VkDevice, swapchainCount: uint32, pCreateInfos: ptr VkSwapchainCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSwapchains: ptr VkSwapchainKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateSharedSwapchainsKHR"))

# Load VK_KHR_xlib_surface
proc loadVK_KHR_xlib_surface*() =
  vkCreateXlibSurfaceKHR = cast[proc(instance: VkInstance, pCreateInfo: ptr VkXlibSurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateXlibSurfaceKHR"))
  vkGetPhysicalDeviceXlibPresentationSupportKHR = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, dpy: ptr Display , visualID: VisualID): VkBool32 {.stdcall.}](vkGetProc("vkGetPhysicalDeviceXlibPresentationSupportKHR"))

# Load VK_KHR_xcb_surface
proc loadVK_KHR_xcb_surface*() =
  vkCreateXcbSurfaceKHR = cast[proc(instance: VkInstance, pCreateInfo: ptr VkXcbSurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateXcbSurfaceKHR"))
  vkGetPhysicalDeviceXcbPresentationSupportKHR = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, connection: ptr xcb_connection_t , visual_id: xcb_visualid_t): VkBool32 {.stdcall.}](vkGetProc("vkGetPhysicalDeviceXcbPresentationSupportKHR"))

# Load VK_KHR_wayland_surface
proc loadVK_KHR_wayland_surface*() =
  vkCreateWaylandSurfaceKHR = cast[proc(instance: VkInstance, pCreateInfo: ptr VkWaylandSurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateWaylandSurfaceKHR"))
  vkGetPhysicalDeviceWaylandPresentationSupportKHR = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, display: ptr wl_display ): VkBool32 {.stdcall.}](vkGetProc("vkGetPhysicalDeviceWaylandPresentationSupportKHR"))

# Load VK_KHR_android_surface
proc loadVK_KHR_android_surface*() =
  vkCreateAndroidSurfaceKHR = cast[proc(instance: VkInstance, pCreateInfo: ptr VkAndroidSurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateAndroidSurfaceKHR"))

# Load VK_KHR_win32_surface
proc loadVK_KHR_win32_surface*() =
  vkCreateWin32SurfaceKHR = cast[proc(instance: VkInstance, pCreateInfo: ptr VkWin32SurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateWin32SurfaceKHR"))
  vkGetPhysicalDeviceWin32PresentationSupportKHR = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32): VkBool32 {.stdcall.}](vkGetProc("vkGetPhysicalDeviceWin32PresentationSupportKHR"))

# Load VK_ANDROID_native_buffer
proc loadVK_ANDROID_native_buffer*() =
  vkGetSwapchainGrallocUsageANDROID = cast[proc(device: VkDevice, format: VkFormat, imageUsage: VkImageUsageFlags, grallocUsage: ptr int ): VkResult {.stdcall.}](vkGetProc("vkGetSwapchainGrallocUsageANDROID"))
  vkAcquireImageANDROID = cast[proc(device: VkDevice, image: VkImage, nativeFenceFd: int, semaphore: VkSemaphore, fence: VkFence): VkResult {.stdcall.}](vkGetProc("vkAcquireImageANDROID"))
  vkQueueSignalReleaseImageANDROID = cast[proc(queue: VkQueue, waitSemaphoreCount: uint32, pWaitSemaphores: ptr VkSemaphore , image: VkImage, pNativeFenceFd: ptr int ): VkResult {.stdcall.}](vkGetProc("vkQueueSignalReleaseImageANDROID"))
  vkGetSwapchainGrallocUsage2ANDROID = cast[proc(device: VkDevice, format: VkFormat, imageUsage: VkImageUsageFlags, swapchainImageUsage: VkSwapchainImageUsageFlagsANDROID, grallocConsumerUsage: ptr uint64 , grallocProducerUsage: ptr uint64 ): VkResult {.stdcall.}](vkGetProc("vkGetSwapchainGrallocUsage2ANDROID"))

# Load VK_EXT_debug_report
proc loadVK_EXT_debug_report*() =
  vkCreateDebugReportCallbackEXT = cast[proc(instance: VkInstance, pCreateInfo: ptr VkDebugReportCallbackCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pCallback: ptr VkDebugReportCallbackEXT ): VkResult {.stdcall.}](vkGetProc("vkCreateDebugReportCallbackEXT"))
  vkDestroyDebugReportCallbackEXT = cast[proc(instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyDebugReportCallbackEXT"))
  vkDebugReportMessageEXT = cast[proc(instance: VkInstance, flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, `object`: uint64, location: uint, messageCode: int32, pLayerPrefix: cstring , pMessage: cstring ): void {.stdcall.}](vkGetProc("vkDebugReportMessageEXT"))

# Load VK_EXT_debug_marker
proc loadVK_EXT_debug_marker*() =
  vkDebugMarkerSetObjectTagEXT = cast[proc(device: VkDevice, pTagInfo: ptr VkDebugMarkerObjectTagInfoEXT ): VkResult {.stdcall.}](vkGetProc("vkDebugMarkerSetObjectTagEXT"))
  vkDebugMarkerSetObjectNameEXT = cast[proc(device: VkDevice, pNameInfo: ptr VkDebugMarkerObjectNameInfoEXT ): VkResult {.stdcall.}](vkGetProc("vkDebugMarkerSetObjectNameEXT"))
  vkCmdDebugMarkerBeginEXT = cast[proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkDebugMarkerMarkerInfoEXT ): void {.stdcall.}](vkGetProc("vkCmdDebugMarkerBeginEXT"))
  vkCmdDebugMarkerEndEXT = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetProc("vkCmdDebugMarkerEndEXT"))
  vkCmdDebugMarkerInsertEXT = cast[proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkDebugMarkerMarkerInfoEXT ): void {.stdcall.}](vkGetProc("vkCmdDebugMarkerInsertEXT"))

# Load VK_EXT_transform_feedback
proc loadVK_EXT_transform_feedback*() =
  vkCmdBindTransformFeedbackBuffersEXT = cast[proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer , pOffsets: ptr VkDeviceSize , pSizes: ptr VkDeviceSize ): void {.stdcall.}](vkGetProc("vkCmdBindTransformFeedbackBuffersEXT"))
  vkCmdBeginTransformFeedbackEXT = cast[proc(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32, counterBufferCount: uint32, pCounterBuffers: ptr VkBuffer , pCounterBufferOffsets: ptr VkDeviceSize ): void {.stdcall.}](vkGetProc("vkCmdBeginTransformFeedbackEXT"))
  vkCmdEndTransformFeedbackEXT = cast[proc(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32, counterBufferCount: uint32, pCounterBuffers: ptr VkBuffer , pCounterBufferOffsets: ptr VkDeviceSize ): void {.stdcall.}](vkGetProc("vkCmdEndTransformFeedbackEXT"))
  vkCmdBeginQueryIndexedEXT = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, flags: VkQueryControlFlags, index: uint32): void {.stdcall.}](vkGetProc("vkCmdBeginQueryIndexedEXT"))
  vkCmdEndQueryIndexedEXT = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, index: uint32): void {.stdcall.}](vkGetProc("vkCmdEndQueryIndexedEXT"))
  vkCmdDrawIndirectByteCountEXT = cast[proc(commandBuffer: VkCommandBuffer, instanceCount: uint32, firstInstance: uint32, counterBuffer: VkBuffer, counterBufferOffset: VkDeviceSize, counterOffset: uint32, vertexStride: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawIndirectByteCountEXT"))

# Load VK_NVX_image_view_handle
proc loadVK_NVX_image_view_handle*() =
  vkGetImageViewHandleNVX = cast[proc(device: VkDevice, pInfo: ptr VkImageViewHandleInfoNVX ): uint32 {.stdcall.}](vkGetProc("vkGetImageViewHandleNVX"))
  vkGetImageViewAddressNVX = cast[proc(device: VkDevice, imageView: VkImageView, pProperties: ptr VkImageViewAddressPropertiesNVX ): VkResult {.stdcall.}](vkGetProc("vkGetImageViewAddressNVX"))

# Load VK_AMD_shader_info
proc loadVK_AMD_shader_info*() =
  vkGetShaderInfoAMD = cast[proc(device: VkDevice, pipeline: VkPipeline, shaderStage: VkShaderStageFlagBits, infoType: VkShaderInfoTypeAMD, pInfoSize: ptr uint , pInfo: pointer ): VkResult {.stdcall.}](vkGetProc("vkGetShaderInfoAMD"))

# Load VK_GGP_stream_descriptor_surface
proc loadVK_GGP_stream_descriptor_surface*() =
  vkCreateStreamDescriptorSurfaceGGP = cast[proc(instance: VkInstance, pCreateInfo: ptr VkStreamDescriptorSurfaceCreateInfoGGP , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateStreamDescriptorSurfaceGGP"))

# Load VK_NV_external_memory_capabilities
proc loadVK_NV_external_memory_capabilities*() =
  vkGetPhysicalDeviceExternalImageFormatPropertiesNV = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, `type`: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, externalHandleType: VkExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: ptr VkExternalImageFormatPropertiesNV ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceExternalImageFormatPropertiesNV"))

# Load VK_NV_external_memory_win32
proc loadVK_NV_external_memory_win32*() =
  vkGetMemoryWin32HandleNV = cast[proc(device: VkDevice, memory: VkDeviceMemory, handleType: VkExternalMemoryHandleTypeFlagsNV, pHandle: ptr HANDLE ): VkResult {.stdcall.}](vkGetProc("vkGetMemoryWin32HandleNV"))

# Load VK_KHR_device_group
proc loadVK_KHR_device_group*() =
  vkGetDeviceGroupPresentCapabilitiesKHR = cast[proc(device: VkDevice, pDeviceGroupPresentCapabilities: ptr VkDeviceGroupPresentCapabilitiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDeviceGroupPresentCapabilitiesKHR"))
  vkGetDeviceGroupSurfacePresentModesKHR = cast[proc(device: VkDevice, surface: VkSurfaceKHR, pModes: ptr VkDeviceGroupPresentModeFlagsKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDeviceGroupSurfacePresentModesKHR"))
  vkGetPhysicalDevicePresentRectanglesKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: ptr uint32 , pRects: ptr VkRect2D ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDevicePresentRectanglesKHR"))
  vkAcquireNextImage2KHR = cast[proc(device: VkDevice, pAcquireInfo: ptr VkAcquireNextImageInfoKHR , pImageIndex: ptr uint32 ): VkResult {.stdcall.}](vkGetProc("vkAcquireNextImage2KHR"))

# Load VK_NN_vi_surface
proc loadVK_NN_vi_surface*() =
  vkCreateViSurfaceNN = cast[proc(instance: VkInstance, pCreateInfo: ptr VkViSurfaceCreateInfoNN , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateViSurfaceNN"))

# Load VK_KHR_external_memory_win32
proc loadVK_KHR_external_memory_win32*() =
  vkGetMemoryWin32HandleKHR = cast[proc(device: VkDevice, pGetWin32HandleInfo: ptr VkMemoryGetWin32HandleInfoKHR , pHandle: ptr HANDLE ): VkResult {.stdcall.}](vkGetProc("vkGetMemoryWin32HandleKHR"))
  vkGetMemoryWin32HandlePropertiesKHR = cast[proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, handle: HANDLE, pMemoryWin32HandleProperties: ptr VkMemoryWin32HandlePropertiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetMemoryWin32HandlePropertiesKHR"))

# Load VK_KHR_external_memory_fd
proc loadVK_KHR_external_memory_fd*() =
  vkGetMemoryFdKHR = cast[proc(device: VkDevice, pGetFdInfo: ptr VkMemoryGetFdInfoKHR , pFd: ptr int ): VkResult {.stdcall.}](vkGetProc("vkGetMemoryFdKHR"))
  vkGetMemoryFdPropertiesKHR = cast[proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, fd: int, pMemoryFdProperties: ptr VkMemoryFdPropertiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetMemoryFdPropertiesKHR"))

# Load VK_KHR_external_semaphore_win32
proc loadVK_KHR_external_semaphore_win32*() =
  vkImportSemaphoreWin32HandleKHR = cast[proc(device: VkDevice, pImportSemaphoreWin32HandleInfo: ptr VkImportSemaphoreWin32HandleInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkImportSemaphoreWin32HandleKHR"))
  vkGetSemaphoreWin32HandleKHR = cast[proc(device: VkDevice, pGetWin32HandleInfo: ptr VkSemaphoreGetWin32HandleInfoKHR , pHandle: ptr HANDLE ): VkResult {.stdcall.}](vkGetProc("vkGetSemaphoreWin32HandleKHR"))

# Load VK_KHR_external_semaphore_fd
proc loadVK_KHR_external_semaphore_fd*() =
  vkImportSemaphoreFdKHR = cast[proc(device: VkDevice, pImportSemaphoreFdInfo: ptr VkImportSemaphoreFdInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkImportSemaphoreFdKHR"))
  vkGetSemaphoreFdKHR = cast[proc(device: VkDevice, pGetFdInfo: ptr VkSemaphoreGetFdInfoKHR , pFd: ptr int ): VkResult {.stdcall.}](vkGetProc("vkGetSemaphoreFdKHR"))

# Load VK_KHR_push_descriptor
proc loadVK_KHR_push_descriptor*() =
  vkCmdPushDescriptorSetKHR = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32, descriptorWriteCount: uint32, pDescriptorWrites: ptr VkWriteDescriptorSet ): void {.stdcall.}](vkGetProc("vkCmdPushDescriptorSetKHR"))
  vkCmdPushDescriptorSetWithTemplateKHR = cast[proc(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32, pData: pointer ): void {.stdcall.}](vkGetProc("vkCmdPushDescriptorSetWithTemplateKHR"))
  vkCmdPushDescriptorSetWithTemplateKHR = cast[proc(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32, pData: pointer ): void {.stdcall.}](vkGetProc("vkCmdPushDescriptorSetWithTemplateKHR"))

# Load VK_EXT_conditional_rendering
proc loadVK_EXT_conditional_rendering*() =
  vkCmdBeginConditionalRenderingEXT = cast[proc(commandBuffer: VkCommandBuffer, pConditionalRenderingBegin: ptr VkConditionalRenderingBeginInfoEXT ): void {.stdcall.}](vkGetProc("vkCmdBeginConditionalRenderingEXT"))
  vkCmdEndConditionalRenderingEXT = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetProc("vkCmdEndConditionalRenderingEXT"))

# Load VK_KHR_descriptor_update_template
proc loadVK_KHR_descriptor_update_template*() =
  vkCmdPushDescriptorSetWithTemplateKHR = cast[proc(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32, pData: pointer ): void {.stdcall.}](vkGetProc("vkCmdPushDescriptorSetWithTemplateKHR"))

# Load VK_NV_clip_space_w_scaling
proc loadVK_NV_clip_space_w_scaling*() =
  vkCmdSetViewportWScalingNV = cast[proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewportWScalings: ptr VkViewportWScalingNV ): void {.stdcall.}](vkGetProc("vkCmdSetViewportWScalingNV"))

# Load VK_EXT_direct_mode_display
proc loadVK_EXT_direct_mode_display*() =
  vkReleaseDisplayEXT = cast[proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR): VkResult {.stdcall.}](vkGetProc("vkReleaseDisplayEXT"))

# Load VK_EXT_acquire_xlib_display
proc loadVK_EXT_acquire_xlib_display*() =
  vkAcquireXlibDisplayEXT = cast[proc(physicalDevice: VkPhysicalDevice, dpy: ptr Display , display: VkDisplayKHR): VkResult {.stdcall.}](vkGetProc("vkAcquireXlibDisplayEXT"))
  vkGetRandROutputDisplayEXT = cast[proc(physicalDevice: VkPhysicalDevice, dpy: ptr Display , rrOutput: RROutput, pDisplay: ptr VkDisplayKHR ): VkResult {.stdcall.}](vkGetProc("vkGetRandROutputDisplayEXT"))

# Load VK_EXT_display_surface_counter
proc loadVK_EXT_display_surface_counter*() =
  vkGetPhysicalDeviceSurfaceCapabilities2EXT = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: ptr VkSurfaceCapabilities2EXT ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSurfaceCapabilities2EXT"))

# Load VK_EXT_display_control
proc loadVK_EXT_display_control*() =
  vkDisplayPowerControlEXT = cast[proc(device: VkDevice, display: VkDisplayKHR, pDisplayPowerInfo: ptr VkDisplayPowerInfoEXT ): VkResult {.stdcall.}](vkGetProc("vkDisplayPowerControlEXT"))
  vkRegisterDeviceEventEXT = cast[proc(device: VkDevice, pDeviceEventInfo: ptr VkDeviceEventInfoEXT , pAllocator: ptr VkAllocationCallbacks , pFence: ptr VkFence ): VkResult {.stdcall.}](vkGetProc("vkRegisterDeviceEventEXT"))
  vkRegisterDisplayEventEXT = cast[proc(device: VkDevice, display: VkDisplayKHR, pDisplayEventInfo: ptr VkDisplayEventInfoEXT , pAllocator: ptr VkAllocationCallbacks , pFence: ptr VkFence ): VkResult {.stdcall.}](vkGetProc("vkRegisterDisplayEventEXT"))
  vkGetSwapchainCounterEXT = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, counter: VkSurfaceCounterFlagBitsEXT, pCounterValue: ptr uint64 ): VkResult {.stdcall.}](vkGetProc("vkGetSwapchainCounterEXT"))

# Load VK_GOOGLE_display_timing
proc loadVK_GOOGLE_display_timing*() =
  vkGetRefreshCycleDurationGOOGLE = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, pDisplayTimingProperties: ptr VkRefreshCycleDurationGOOGLE ): VkResult {.stdcall.}](vkGetProc("vkGetRefreshCycleDurationGOOGLE"))
  vkGetPastPresentationTimingGOOGLE = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, pPresentationTimingCount: ptr uint32 , pPresentationTimings: ptr VkPastPresentationTimingGOOGLE ): VkResult {.stdcall.}](vkGetProc("vkGetPastPresentationTimingGOOGLE"))

# Load VK_EXT_discard_rectangles
proc loadVK_EXT_discard_rectangles*() =
  vkCmdSetDiscardRectangleEXT = cast[proc(commandBuffer: VkCommandBuffer, firstDiscardRectangle: uint32, discardRectangleCount: uint32, pDiscardRectangles: ptr VkRect2D ): void {.stdcall.}](vkGetProc("vkCmdSetDiscardRectangleEXT"))

# Load VK_EXT_hdr_metadata
proc loadVK_EXT_hdr_metadata*() =
  vkSetHdrMetadataEXT = cast[proc(device: VkDevice, swapchainCount: uint32, pSwapchains: ptr VkSwapchainKHR , pMetadata: ptr VkHdrMetadataEXT ): void {.stdcall.}](vkGetProc("vkSetHdrMetadataEXT"))

# Load VK_KHR_shared_presentable_image
proc loadVK_KHR_shared_presentable_image*() =
  vkGetSwapchainStatusKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR): VkResult {.stdcall.}](vkGetProc("vkGetSwapchainStatusKHR"))

# Load VK_KHR_external_fence_win32
proc loadVK_KHR_external_fence_win32*() =
  vkImportFenceWin32HandleKHR = cast[proc(device: VkDevice, pImportFenceWin32HandleInfo: ptr VkImportFenceWin32HandleInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkImportFenceWin32HandleKHR"))
  vkGetFenceWin32HandleKHR = cast[proc(device: VkDevice, pGetWin32HandleInfo: ptr VkFenceGetWin32HandleInfoKHR , pHandle: ptr HANDLE ): VkResult {.stdcall.}](vkGetProc("vkGetFenceWin32HandleKHR"))

# Load VK_KHR_external_fence_fd
proc loadVK_KHR_external_fence_fd*() =
  vkImportFenceFdKHR = cast[proc(device: VkDevice, pImportFenceFdInfo: ptr VkImportFenceFdInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkImportFenceFdKHR"))
  vkGetFenceFdKHR = cast[proc(device: VkDevice, pGetFdInfo: ptr VkFenceGetFdInfoKHR , pFd: ptr int ): VkResult {.stdcall.}](vkGetProc("vkGetFenceFdKHR"))

# Load VK_KHR_performance_query
proc loadVK_KHR_performance_query*() =
  vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, pCounterCount: ptr uint32 , pCounters: ptr VkPerformanceCounterKHR , pCounterDescriptions: ptr VkPerformanceCounterDescriptionKHR ): VkResult {.stdcall.}](vkGetProc("vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"))
  vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = cast[proc(physicalDevice: VkPhysicalDevice, pPerformanceQueryCreateInfo: ptr VkQueryPoolPerformanceCreateInfoKHR , pNumPasses: ptr uint32 ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"))
  vkAcquireProfilingLockKHR = cast[proc(device: VkDevice, pInfo: ptr VkAcquireProfilingLockInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkAcquireProfilingLockKHR"))
  vkReleaseProfilingLockKHR = cast[proc(device: VkDevice): void {.stdcall.}](vkGetProc("vkReleaseProfilingLockKHR"))

# Load VK_KHR_get_surface_capabilities2
proc loadVK_KHR_get_surface_capabilities2*() =
  vkGetPhysicalDeviceSurfaceCapabilities2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pSurfaceCapabilities: ptr VkSurfaceCapabilities2KHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSurfaceCapabilities2KHR"))
  vkGetPhysicalDeviceSurfaceFormats2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pSurfaceFormatCount: ptr uint32 , pSurfaceFormats: ptr VkSurfaceFormat2KHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSurfaceFormats2KHR"))

# Load VK_KHR_get_display_properties2
proc loadVK_KHR_get_display_properties2*() =
  vkGetPhysicalDeviceDisplayProperties2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayProperties2KHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceDisplayProperties2KHR"))
  vkGetPhysicalDeviceDisplayPlaneProperties2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayPlaneProperties2KHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceDisplayPlaneProperties2KHR"))
  vkGetDisplayModeProperties2KHR = cast[proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayModeProperties2KHR ): VkResult {.stdcall.}](vkGetProc("vkGetDisplayModeProperties2KHR"))
  vkGetDisplayPlaneCapabilities2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pDisplayPlaneInfo: ptr VkDisplayPlaneInfo2KHR , pCapabilities: ptr VkDisplayPlaneCapabilities2KHR ): VkResult {.stdcall.}](vkGetProc("vkGetDisplayPlaneCapabilities2KHR"))

# Load VK_MVK_ios_surface
proc loadVK_MVK_ios_surface*() =
  vkCreateIOSSurfaceMVK = cast[proc(instance: VkInstance, pCreateInfo: ptr VkIOSSurfaceCreateInfoMVK , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateIOSSurfaceMVK"))

# Load VK_MVK_macos_surface
proc loadVK_MVK_macos_surface*() =
  vkCreateMacOSSurfaceMVK = cast[proc(instance: VkInstance, pCreateInfo: ptr VkMacOSSurfaceCreateInfoMVK , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateMacOSSurfaceMVK"))

# Load VK_EXT_debug_utils
proc loadVK_EXT_debug_utils*(instance: VkInstance) =
  vkSetDebugUtilsObjectNameEXT = cast[proc(device: VkDevice, pNameInfo: ptr VkDebugUtilsObjectNameInfoEXT ): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectNameEXT"))
  vkSetDebugUtilsObjectTagEXT = cast[proc(device: VkDevice, pTagInfo: ptr VkDebugUtilsObjectTagInfoEXT ): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectTagEXT"))
  vkQueueBeginDebugUtilsLabelEXT = cast[proc(queue: VkQueue, pLabelInfo: ptr VkDebugUtilsLabelEXT ): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueBeginDebugUtilsLabelEXT"))
  vkQueueEndDebugUtilsLabelEXT = cast[proc(queue: VkQueue): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueEndDebugUtilsLabelEXT"))
  vkQueueInsertDebugUtilsLabelEXT = cast[proc(queue: VkQueue, pLabelInfo: ptr VkDebugUtilsLabelEXT ): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueInsertDebugUtilsLabelEXT"))
  vkCmdBeginDebugUtilsLabelEXT = cast[proc(commandBuffer: VkCommandBuffer, pLabelInfo: ptr VkDebugUtilsLabelEXT ): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginDebugUtilsLabelEXT"))
  vkCmdEndDebugUtilsLabelEXT = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndDebugUtilsLabelEXT"))
  vkCmdInsertDebugUtilsLabelEXT = cast[proc(commandBuffer: VkCommandBuffer, pLabelInfo: ptr VkDebugUtilsLabelEXT ): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdInsertDebugUtilsLabelEXT"))
  vkCreateDebugUtilsMessengerEXT = cast[proc(instance: VkInstance, pCreateInfo: ptr VkDebugUtilsMessengerCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pMessenger: ptr VkDebugUtilsMessengerEXT ): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT"))
  vkDestroyDebugUtilsMessengerEXT = cast[proc(instance: VkInstance, messenger: VkDebugUtilsMessengerEXT, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT"))
  vkSubmitDebugUtilsMessageEXT = cast[proc(instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: ptr VkDebugUtilsMessengerCallbackDataEXT ): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSubmitDebugUtilsMessageEXT"))

# Load VK_ANDROID_external_memory_android_hardware_buffer
proc loadVK_ANDROID_external_memory_android_hardware_buffer*() =
  vkGetAndroidHardwareBufferPropertiesANDROID = cast[proc(device: VkDevice, buffer: ptr AHardwareBuffer , pProperties: ptr VkAndroidHardwareBufferPropertiesANDROID ): VkResult {.stdcall.}](vkGetProc("vkGetAndroidHardwareBufferPropertiesANDROID"))
  vkGetMemoryAndroidHardwareBufferANDROID = cast[proc(device: VkDevice, pInfo: ptr VkMemoryGetAndroidHardwareBufferInfoANDROID , pBuffer: ptr ptr AHardwareBuffer ): VkResult {.stdcall.}](vkGetProc("vkGetMemoryAndroidHardwareBufferANDROID"))

# Load VK_EXT_sample_locations
proc loadVK_EXT_sample_locations*() =
  vkCmdSetSampleLocationsEXT = cast[proc(commandBuffer: VkCommandBuffer, pSampleLocationsInfo: ptr VkSampleLocationsInfoEXT ): void {.stdcall.}](vkGetProc("vkCmdSetSampleLocationsEXT"))
  vkGetPhysicalDeviceMultisamplePropertiesEXT = cast[proc(physicalDevice: VkPhysicalDevice, samples: VkSampleCountFlagBits, pMultisampleProperties: ptr VkMultisamplePropertiesEXT ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceMultisamplePropertiesEXT"))

# Load VK_KHR_ray_tracing
proc loadVK_KHR_ray_tracing*() =
  vkCreateAccelerationStructureKHR = cast[proc(device: VkDevice, pCreateInfo: ptr VkAccelerationStructureCreateInfoKHR        , pAllocator: ptr VkAllocationCallbacks       , pAccelerationStructure: ptr VkAccelerationStructureKHR                        ): VkResult {.stdcall.}](vkGetProc("vkCreateAccelerationStructureKHR"))
  vkDestroyAccelerationStructureKHR = cast[proc(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyAccelerationStructureKHR"))
  vkGetAccelerationStructureMemoryRequirementsKHR = cast[proc(device: VkDevice, pInfo: ptr VkAccelerationStructureMemoryRequirementsInfoKHR , pMemoryRequirements: ptr VkMemoryRequirements2 ): void {.stdcall.}](vkGetProc("vkGetAccelerationStructureMemoryRequirementsKHR"))
  vkBindAccelerationStructureMemoryKHR = cast[proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindAccelerationStructureMemoryInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkBindAccelerationStructureMemoryKHR"))
  vkCmdBuildAccelerationStructureKHR = cast[proc(commandBuffer: VkCommandBuffer, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR , ppOffsetInfos: ptr ptr VkAccelerationStructureBuildOffsetInfoKHR ): void {.stdcall.}](vkGetProc("vkCmdBuildAccelerationStructureKHR"))
  vkCmdBuildAccelerationStructureIndirectKHR = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkAccelerationStructureBuildGeometryInfoKHR , indirectBuffer: VkBuffer, indirectOffset: VkDeviceSize, indirectStride: uint32): void {.stdcall.}](vkGetProc("vkCmdBuildAccelerationStructureIndirectKHR"))
  vkBuildAccelerationStructureKHR = cast[proc(device: VkDevice, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR , ppOffsetInfos: ptr ptr VkAccelerationStructureBuildOffsetInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkBuildAccelerationStructureKHR"))
  vkCopyAccelerationStructureKHR = cast[proc(device: VkDevice, pInfo: ptr VkCopyAccelerationStructureInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkCopyAccelerationStructureKHR"))
  vkCopyAccelerationStructureToMemoryKHR = cast[proc(device: VkDevice, pInfo: ptr VkCopyAccelerationStructureToMemoryInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkCopyAccelerationStructureToMemoryKHR"))
  vkCopyMemoryToAccelerationStructureKHR = cast[proc(device: VkDevice, pInfo: ptr VkCopyMemoryToAccelerationStructureInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkCopyMemoryToAccelerationStructureKHR"))
  vkWriteAccelerationStructuresPropertiesKHR = cast[proc(device: VkDevice, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR , queryType: VkQueryType, dataSize: uint, pData: pointer , stride: uint): VkResult {.stdcall.}](vkGetProc("vkWriteAccelerationStructuresPropertiesKHR"))
  vkCmdCopyAccelerationStructureKHR = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyAccelerationStructureInfoKHR ): void {.stdcall.}](vkGetProc("vkCmdCopyAccelerationStructureKHR"))
  vkCmdCopyAccelerationStructureToMemoryKHR = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyAccelerationStructureToMemoryInfoKHR ): void {.stdcall.}](vkGetProc("vkCmdCopyAccelerationStructureToMemoryKHR"))
  vkCmdCopyMemoryToAccelerationStructureKHR = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMemoryToAccelerationStructureInfoKHR ): void {.stdcall.}](vkGetProc("vkCmdCopyMemoryToAccelerationStructureKHR"))
  vkCmdTraceRaysKHR = cast[proc(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: ptr VkStridedBufferRegionKHR , pMissShaderBindingTable: ptr VkStridedBufferRegionKHR , pHitShaderBindingTable: ptr VkStridedBufferRegionKHR , pCallableShaderBindingTable: ptr VkStridedBufferRegionKHR , width: uint32, height: uint32, depth: uint32): void {.stdcall.}](vkGetProc("vkCmdTraceRaysKHR"))
  vkCreateRayTracingPipelinesKHR = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkRayTracingPipelineCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pPipelines: ptr VkPipeline ): VkResult {.stdcall.}](vkGetProc("vkCreateRayTracingPipelinesKHR"))
  vkGetRayTracingShaderGroupHandlesKHR = cast[proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: uint, pData: pointer ): VkResult {.stdcall.}](vkGetProc("vkGetRayTracingShaderGroupHandlesKHR"))
  vkGetAccelerationStructureDeviceAddressKHR = cast[proc(device: VkDevice, pInfo: ptr VkAccelerationStructureDeviceAddressInfoKHR ): VkDeviceAddress {.stdcall.}](vkGetProc("vkGetAccelerationStructureDeviceAddressKHR"))
  vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = cast[proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: uint, pData: pointer ): VkResult {.stdcall.}](vkGetProc("vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"))
  vkCmdWriteAccelerationStructuresPropertiesKHR = cast[proc(commandBuffer: VkCommandBuffer, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR , queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32): void {.stdcall.}](vkGetProc("vkCmdWriteAccelerationStructuresPropertiesKHR"))
  vkCmdTraceRaysIndirectKHR = cast[proc(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: ptr VkStridedBufferRegionKHR , pMissShaderBindingTable: ptr VkStridedBufferRegionKHR , pHitShaderBindingTable: ptr VkStridedBufferRegionKHR , pCallableShaderBindingTable: ptr VkStridedBufferRegionKHR , buffer: VkBuffer, offset: VkDeviceSize): void {.stdcall.}](vkGetProc("vkCmdTraceRaysIndirectKHR"))
  vkGetDeviceAccelerationStructureCompatibilityKHR = cast[proc(device: VkDevice, version: ptr VkAccelerationStructureVersionKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDeviceAccelerationStructureCompatibilityKHR"))

# Load VK_EXT_image_drm_format_modifier
proc loadVK_EXT_image_drm_format_modifier*() =
  vkGetImageDrmFormatModifierPropertiesEXT = cast[proc(device: VkDevice, image: VkImage, pProperties: ptr VkImageDrmFormatModifierPropertiesEXT ): VkResult {.stdcall.}](vkGetProc("vkGetImageDrmFormatModifierPropertiesEXT"))

# Load VK_EXT_validation_cache
proc loadVK_EXT_validation_cache*() =
  vkCreateValidationCacheEXT = cast[proc(device: VkDevice, pCreateInfo: ptr VkValidationCacheCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pValidationCache: ptr VkValidationCacheEXT ): VkResult {.stdcall.}](vkGetProc("vkCreateValidationCacheEXT"))
  vkDestroyValidationCacheEXT = cast[proc(device: VkDevice, validationCache: VkValidationCacheEXT, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyValidationCacheEXT"))
  vkMergeValidationCachesEXT = cast[proc(device: VkDevice, dstCache: VkValidationCacheEXT, srcCacheCount: uint32, pSrcCaches: ptr VkValidationCacheEXT ): VkResult {.stdcall.}](vkGetProc("vkMergeValidationCachesEXT"))
  vkGetValidationCacheDataEXT = cast[proc(device: VkDevice, validationCache: VkValidationCacheEXT, pDataSize: ptr uint , pData: pointer ): VkResult {.stdcall.}](vkGetProc("vkGetValidationCacheDataEXT"))

# Load VK_NV_shading_rate_image
proc loadVK_NV_shading_rate_image*() =
  vkCmdBindShadingRateImageNV = cast[proc(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout): void {.stdcall.}](vkGetProc("vkCmdBindShadingRateImageNV"))
  vkCmdSetViewportShadingRatePaletteNV = cast[proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pShadingRatePalettes: ptr VkShadingRatePaletteNV ): void {.stdcall.}](vkGetProc("vkCmdSetViewportShadingRatePaletteNV"))
  vkCmdSetCoarseSampleOrderNV = cast[proc(commandBuffer: VkCommandBuffer, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: uint32, pCustomSampleOrders: ptr VkCoarseSampleOrderCustomNV ): void {.stdcall.}](vkGetProc("vkCmdSetCoarseSampleOrderNV"))

# Load VK_NV_ray_tracing
proc loadVK_NV_ray_tracing*() =
  vkCreateAccelerationStructureNV = cast[proc(device: VkDevice, pCreateInfo: ptr VkAccelerationStructureCreateInfoNV , pAllocator: ptr VkAllocationCallbacks , pAccelerationStructure: ptr VkAccelerationStructureNV ): VkResult {.stdcall.}](vkGetProc("vkCreateAccelerationStructureNV"))
  vkGetAccelerationStructureMemoryRequirementsNV = cast[proc(device: VkDevice, pInfo: ptr VkAccelerationStructureMemoryRequirementsInfoNV , pMemoryRequirements: ptr VkMemoryRequirements2KHR ): void {.stdcall.}](vkGetProc("vkGetAccelerationStructureMemoryRequirementsNV"))
  vkCmdBuildAccelerationStructureNV = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkAccelerationStructureInfoNV , instanceData: VkBuffer, instanceOffset: VkDeviceSize, update: VkBool32, dst: VkAccelerationStructureKHR, src: VkAccelerationStructureKHR, scratch: VkBuffer, scratchOffset: VkDeviceSize): void {.stdcall.}](vkGetProc("vkCmdBuildAccelerationStructureNV"))
  vkCmdCopyAccelerationStructureNV = cast[proc(commandBuffer: VkCommandBuffer, dst: VkAccelerationStructureKHR, src: VkAccelerationStructureKHR, mode: VkCopyAccelerationStructureModeKHR): void {.stdcall.}](vkGetProc("vkCmdCopyAccelerationStructureNV"))
  vkCmdTraceRaysNV = cast[proc(commandBuffer: VkCommandBuffer, raygenShaderBindingTableBuffer: VkBuffer, raygenShaderBindingOffset: VkDeviceSize, missShaderBindingTableBuffer: VkBuffer, missShaderBindingOffset: VkDeviceSize, missShaderBindingStride: VkDeviceSize, hitShaderBindingTableBuffer: VkBuffer, hitShaderBindingOffset: VkDeviceSize, hitShaderBindingStride: VkDeviceSize, callableShaderBindingTableBuffer: VkBuffer, callableShaderBindingOffset: VkDeviceSize, callableShaderBindingStride: VkDeviceSize, width: uint32, height: uint32, depth: uint32): void {.stdcall.}](vkGetProc("vkCmdTraceRaysNV"))
  vkCreateRayTracingPipelinesNV = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkRayTracingPipelineCreateInfoNV , pAllocator: ptr VkAllocationCallbacks , pPipelines: ptr VkPipeline ): VkResult {.stdcall.}](vkGetProc("vkCreateRayTracingPipelinesNV"))
  vkGetAccelerationStructureHandleNV = cast[proc(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, dataSize: uint, pData: pointer ): VkResult {.stdcall.}](vkGetProc("vkGetAccelerationStructureHandleNV"))
  vkCompileDeferredNV = cast[proc(device: VkDevice, pipeline: VkPipeline, shader: uint32): VkResult {.stdcall.}](vkGetProc("vkCompileDeferredNV"))

# Load VK_EXT_external_memory_host
proc loadVK_EXT_external_memory_host*() =
  vkGetMemoryHostPointerPropertiesEXT = cast[proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, pHostPointer: pointer , pMemoryHostPointerProperties: ptr VkMemoryHostPointerPropertiesEXT ): VkResult {.stdcall.}](vkGetProc("vkGetMemoryHostPointerPropertiesEXT"))

# Load VK_AMD_buffer_marker
proc loadVK_AMD_buffer_marker*() =
  vkCmdWriteBufferMarkerAMD = cast[proc(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: uint32): void {.stdcall.}](vkGetProc("vkCmdWriteBufferMarkerAMD"))

# Load VK_EXT_calibrated_timestamps
proc loadVK_EXT_calibrated_timestamps*() =
  vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = cast[proc(physicalDevice: VkPhysicalDevice, pTimeDomainCount: ptr uint32 , pTimeDomains: ptr VkTimeDomainEXT ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"))
  vkGetCalibratedTimestampsEXT = cast[proc(device: VkDevice, timestampCount: uint32, pTimestampInfos: ptr VkCalibratedTimestampInfoEXT , pTimestamps: ptr uint64 , pMaxDeviation: ptr uint64 ): VkResult {.stdcall.}](vkGetProc("vkGetCalibratedTimestampsEXT"))

# Load VK_NV_mesh_shader
proc loadVK_NV_mesh_shader*() =
  vkCmdDrawMeshTasksNV = cast[proc(commandBuffer: VkCommandBuffer, taskCount: uint32, firstTask: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawMeshTasksNV"))
  vkCmdDrawMeshTasksIndirectNV = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawMeshTasksIndirectNV"))
  vkCmdDrawMeshTasksIndirectCountNV = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawMeshTasksIndirectCountNV"))

# Load VK_NV_scissor_exclusive
proc loadVK_NV_scissor_exclusive*() =
  vkCmdSetExclusiveScissorNV = cast[proc(commandBuffer: VkCommandBuffer, firstExclusiveScissor: uint32, exclusiveScissorCount: uint32, pExclusiveScissors: ptr VkRect2D ): void {.stdcall.}](vkGetProc("vkCmdSetExclusiveScissorNV"))

# Load VK_NV_device_diagnostic_checkpoints
proc loadVK_NV_device_diagnostic_checkpoints*() =
  vkCmdSetCheckpointNV = cast[proc(commandBuffer: VkCommandBuffer, pCheckpointMarker: pointer ): void {.stdcall.}](vkGetProc("vkCmdSetCheckpointNV"))
  vkGetQueueCheckpointDataNV = cast[proc(queue: VkQueue, pCheckpointDataCount: ptr uint32 , pCheckpointData: ptr VkCheckpointDataNV ): void {.stdcall.}](vkGetProc("vkGetQueueCheckpointDataNV"))

# Load VK_INTEL_performance_query
proc loadVK_INTEL_performance_query*() =
  vkInitializePerformanceApiINTEL = cast[proc(device: VkDevice, pInitializeInfo: ptr VkInitializePerformanceApiInfoINTEL ): VkResult {.stdcall.}](vkGetProc("vkInitializePerformanceApiINTEL"))
  vkUninitializePerformanceApiINTEL = cast[proc(device: VkDevice): void {.stdcall.}](vkGetProc("vkUninitializePerformanceApiINTEL"))
  vkCmdSetPerformanceMarkerINTEL = cast[proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkPerformanceMarkerInfoINTEL ): VkResult {.stdcall.}](vkGetProc("vkCmdSetPerformanceMarkerINTEL"))
  vkCmdSetPerformanceStreamMarkerINTEL = cast[proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkPerformanceStreamMarkerInfoINTEL ): VkResult {.stdcall.}](vkGetProc("vkCmdSetPerformanceStreamMarkerINTEL"))
  vkCmdSetPerformanceOverrideINTEL = cast[proc(commandBuffer: VkCommandBuffer, pOverrideInfo: ptr VkPerformanceOverrideInfoINTEL ): VkResult {.stdcall.}](vkGetProc("vkCmdSetPerformanceOverrideINTEL"))
  vkAcquirePerformanceConfigurationINTEL = cast[proc(device: VkDevice, pAcquireInfo: ptr VkPerformanceConfigurationAcquireInfoINTEL , pConfiguration: ptr VkPerformanceConfigurationINTEL ): VkResult {.stdcall.}](vkGetProc("vkAcquirePerformanceConfigurationINTEL"))
  vkReleasePerformanceConfigurationINTEL = cast[proc(device: VkDevice, configuration: VkPerformanceConfigurationINTEL): VkResult {.stdcall.}](vkGetProc("vkReleasePerformanceConfigurationINTEL"))
  vkQueueSetPerformanceConfigurationINTEL = cast[proc(queue: VkQueue, configuration: VkPerformanceConfigurationINTEL): VkResult {.stdcall.}](vkGetProc("vkQueueSetPerformanceConfigurationINTEL"))
  vkGetPerformanceParameterINTEL = cast[proc(device: VkDevice, parameter: VkPerformanceParameterTypeINTEL, pValue: ptr VkPerformanceValueINTEL ): VkResult {.stdcall.}](vkGetProc("vkGetPerformanceParameterINTEL"))

# Load VK_AMD_display_native_hdr
proc loadVK_AMD_display_native_hdr*() =
  vkSetLocalDimmingAMD = cast[proc(device: VkDevice, swapChain: VkSwapchainKHR, localDimmingEnable: VkBool32): void {.stdcall.}](vkGetProc("vkSetLocalDimmingAMD"))

# Load VK_FUCHSIA_imagepipe_surface
proc loadVK_FUCHSIA_imagepipe_surface*() =
  vkCreateImagePipeSurfaceFUCHSIA = cast[proc(instance: VkInstance, pCreateInfo: ptr VkImagePipeSurfaceCreateInfoFUCHSIA , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateImagePipeSurfaceFUCHSIA"))

# Load VK_EXT_metal_surface
proc loadVK_EXT_metal_surface*() =
  vkCreateMetalSurfaceEXT = cast[proc(instance: VkInstance, pCreateInfo: ptr VkMetalSurfaceCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateMetalSurfaceEXT"))

# Load VK_EXT_tooling_info
proc loadVK_EXT_tooling_info*() =
  vkGetPhysicalDeviceToolPropertiesEXT = cast[proc(physicalDevice: VkPhysicalDevice, pToolCount: ptr uint32 , pToolProperties: ptr VkPhysicalDeviceToolPropertiesEXT ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceToolPropertiesEXT"))

# Load VK_NV_cooperative_matrix
proc loadVK_NV_cooperative_matrix*() =
  vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkCooperativeMatrixPropertiesNV ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceCooperativeMatrixPropertiesNV"))

# Load VK_NV_coverage_reduction_mode
proc loadVK_NV_coverage_reduction_mode*() =
  vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = cast[proc(physicalDevice: VkPhysicalDevice, pCombinationCount: ptr uint32 , pCombinations: ptr VkFramebufferMixedSamplesCombinationNV ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV"))

# Load VK_EXT_full_screen_exclusive
proc loadVK_EXT_full_screen_exclusive*() =
  vkGetPhysicalDeviceSurfacePresentModes2EXT = cast[proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pPresentModeCount: ptr uint32 , pPresentModes: ptr VkPresentModeKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSurfacePresentModes2EXT"))
  vkAcquireFullScreenExclusiveModeEXT = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR): VkResult {.stdcall.}](vkGetProc("vkAcquireFullScreenExclusiveModeEXT"))
  vkReleaseFullScreenExclusiveModeEXT = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR): VkResult {.stdcall.}](vkGetProc("vkReleaseFullScreenExclusiveModeEXT"))
  vkGetDeviceGroupSurfacePresentModes2EXT = cast[proc(device: VkDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pModes: ptr VkDeviceGroupPresentModeFlagsKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDeviceGroupSurfacePresentModes2EXT"))
  vkGetDeviceGroupSurfacePresentModes2EXT = cast[proc(device: VkDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pModes: ptr VkDeviceGroupPresentModeFlagsKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDeviceGroupSurfacePresentModes2EXT"))

# Load VK_EXT_headless_surface
proc loadVK_EXT_headless_surface*() =
  vkCreateHeadlessSurfaceEXT = cast[proc(instance: VkInstance, pCreateInfo: ptr VkHeadlessSurfaceCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateHeadlessSurfaceEXT"))

# Load VK_EXT_line_rasterization
proc loadVK_EXT_line_rasterization*() =
  vkCmdSetLineStippleEXT = cast[proc(commandBuffer: VkCommandBuffer, lineStippleFactor: uint32, lineStipplePattern: uint16): void {.stdcall.}](vkGetProc("vkCmdSetLineStippleEXT"))

# Load VK_EXT_extended_dynamic_state
proc loadVK_EXT_extended_dynamic_state*() =
  vkCmdSetCullModeEXT = cast[proc(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags): void {.stdcall.}](vkGetProc("vkCmdSetCullModeEXT"))
  vkCmdSetFrontFaceEXT = cast[proc(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace): void {.stdcall.}](vkGetProc("vkCmdSetFrontFaceEXT"))
  vkCmdSetPrimitiveTopologyEXT = cast[proc(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology): void {.stdcall.}](vkGetProc("vkCmdSetPrimitiveTopologyEXT"))
  vkCmdSetViewportWithCountEXT = cast[proc(commandBuffer: VkCommandBuffer, viewportCount: uint32, pViewports: ptr VkViewport ): void {.stdcall.}](vkGetProc("vkCmdSetViewportWithCountEXT"))
  vkCmdSetScissorWithCountEXT = cast[proc(commandBuffer: VkCommandBuffer, scissorCount: uint32, pScissors: ptr VkRect2D ): void {.stdcall.}](vkGetProc("vkCmdSetScissorWithCountEXT"))
  vkCmdBindVertexBuffers2EXT = cast[proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer , pOffsets: ptr VkDeviceSize , pSizes: ptr VkDeviceSize , pStrides: ptr VkDeviceSize ): void {.stdcall.}](vkGetProc("vkCmdBindVertexBuffers2EXT"))
  vkCmdSetDepthTestEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32): void {.stdcall.}](vkGetProc("vkCmdSetDepthTestEnableEXT"))
  vkCmdSetDepthWriteEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32): void {.stdcall.}](vkGetProc("vkCmdSetDepthWriteEnableEXT"))
  vkCmdSetDepthCompareOpEXT = cast[proc(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp): void {.stdcall.}](vkGetProc("vkCmdSetDepthCompareOpEXT"))
  vkCmdSetDepthBoundsTestEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32): void {.stdcall.}](vkGetProc("vkCmdSetDepthBoundsTestEnableEXT"))
  vkCmdSetStencilTestEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32): void {.stdcall.}](vkGetProc("vkCmdSetStencilTestEnableEXT"))
  vkCmdSetStencilOpEXT = cast[proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp): void {.stdcall.}](vkGetProc("vkCmdSetStencilOpEXT"))

# Load VK_KHR_deferred_host_operations
proc loadVK_KHR_deferred_host_operations*() =
  vkCreateDeferredOperationKHR = cast[proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks , pDeferredOperation: ptr VkDeferredOperationKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateDeferredOperationKHR"))
  vkDestroyDeferredOperationKHR = cast[proc(device: VkDevice, operation: VkDeferredOperationKHR, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyDeferredOperationKHR"))
  vkGetDeferredOperationMaxConcurrencyKHR = cast[proc(device: VkDevice, operation: VkDeferredOperationKHR): uint32 {.stdcall.}](vkGetProc("vkGetDeferredOperationMaxConcurrencyKHR"))
  vkGetDeferredOperationResultKHR = cast[proc(device: VkDevice, operation: VkDeferredOperationKHR): VkResult {.stdcall.}](vkGetProc("vkGetDeferredOperationResultKHR"))
  vkDeferredOperationJoinKHR = cast[proc(device: VkDevice, operation: VkDeferredOperationKHR): VkResult {.stdcall.}](vkGetProc("vkDeferredOperationJoinKHR"))

# Load VK_KHR_pipeline_executable_properties
proc loadVK_KHR_pipeline_executable_properties*() =
  vkGetPipelineExecutablePropertiesKHR = cast[proc(device: VkDevice, pPipelineInfo: ptr VkPipelineInfoKHR        , pExecutableCount: ptr uint32 , pProperties: ptr VkPipelineExecutablePropertiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPipelineExecutablePropertiesKHR"))
  vkGetPipelineExecutableStatisticsKHR = cast[proc(device: VkDevice, pExecutableInfo: ptr VkPipelineExecutableInfoKHR  , pStatisticCount: ptr uint32 , pStatistics: ptr VkPipelineExecutableStatisticKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPipelineExecutableStatisticsKHR"))
  vkGetPipelineExecutableInternalRepresentationsKHR = cast[proc(device: VkDevice, pExecutableInfo: ptr VkPipelineExecutableInfoKHR  , pInternalRepresentationCount: ptr uint32 , pInternalRepresentations: ptr VkPipelineExecutableInternalRepresentationKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPipelineExecutableInternalRepresentationsKHR"))

# Load VK_NV_device_generated_commands
proc loadVK_NV_device_generated_commands*() =
  vkGetGeneratedCommandsMemoryRequirementsNV = cast[proc(device: VkDevice, pInfo: ptr VkGeneratedCommandsMemoryRequirementsInfoNV , pMemoryRequirements: ptr VkMemoryRequirements2 ): void {.stdcall.}](vkGetProc("vkGetGeneratedCommandsMemoryRequirementsNV"))
  vkCmdPreprocessGeneratedCommandsNV = cast[proc(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: ptr VkGeneratedCommandsInfoNV ): void {.stdcall.}](vkGetProc("vkCmdPreprocessGeneratedCommandsNV"))
  vkCmdExecuteGeneratedCommandsNV = cast[proc(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: ptr VkGeneratedCommandsInfoNV ): void {.stdcall.}](vkGetProc("vkCmdExecuteGeneratedCommandsNV"))
  vkCmdBindPipelineShaderGroupNV = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, groupIndex: uint32): void {.stdcall.}](vkGetProc("vkCmdBindPipelineShaderGroupNV"))
  vkCreateIndirectCommandsLayoutNV = cast[proc(device: VkDevice, pCreateInfo: ptr VkIndirectCommandsLayoutCreateInfoNV , pAllocator: ptr VkAllocationCallbacks , pIndirectCommandsLayout: ptr VkIndirectCommandsLayoutNV ): VkResult {.stdcall.}](vkGetProc("vkCreateIndirectCommandsLayoutNV"))
  vkDestroyIndirectCommandsLayoutNV = cast[proc(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutNV, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyIndirectCommandsLayoutNV"))

# Load VK_EXT_private_data
proc loadVK_EXT_private_data*() =
  vkCreatePrivateDataSlotEXT = cast[proc(device: VkDevice, pCreateInfo: ptr VkPrivateDataSlotCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pPrivateDataSlot: ptr VkPrivateDataSlotEXT ): VkResult {.stdcall.}](vkGetProc("vkCreatePrivateDataSlotEXT"))
  vkDestroyPrivateDataSlotEXT = cast[proc(device: VkDevice, privateDataSlot: VkPrivateDataSlotEXT, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyPrivateDataSlotEXT"))
  vkSetPrivateDataEXT = cast[proc(device: VkDevice, objectType: VkObjectType, objectHandle: uint64, privateDataSlot: VkPrivateDataSlotEXT, data: uint64): VkResult {.stdcall.}](vkGetProc("vkSetPrivateDataEXT"))
  vkGetPrivateDataEXT = cast[proc(device: VkDevice, objectType: VkObjectType, objectHandle: uint64, privateDataSlot: VkPrivateDataSlotEXT, pData: ptr uint64 ): void {.stdcall.}](vkGetProc("vkGetPrivateDataEXT"))

# Load VK_EXT_directfb_surface
proc loadVK_EXT_directfb_surface*() =
  vkCreateDirectFBSurfaceEXT = cast[proc(instance: VkInstance, pCreateInfo: ptr VkDirectFBSurfaceCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateDirectFBSurfaceEXT"))
  vkGetPhysicalDeviceDirectFBPresentationSupportEXT = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, dfb: ptr IDirectFB ): VkBool32 {.stdcall.}](vkGetProc("vkGetPhysicalDeviceDirectFBPresentationSupportEXT"))

proc vkInit*(load1_0: bool = true, load1_1: bool = true): bool =
  if load1_0:
    vkLoad1_0()
  when not defined(macosx):
    if load1_1:
      vkLoad1_1()
  return true