cc/gapir/vulkan_gfx_api.h

////////////////////////////////////////////////////////////////////////////////
// Automatically generated file. Do not modify!
////////////////////////////////////////////////////////////////////////////////



#ifndef GAPIR_VULKAN_GFX_API_H
#define GAPIR_VULKAN_GFX_API_H

#include "gfx_api.h"

#include <gapic/static_array.h>
#include <gapic/target.h>
#include <gapic/vulkan_ptr_types.h>

#include <stdint.h>
#include <string>

struct ANativeWindow;
struct Display;
struct xcb_connection_t;
struct wl_display;
struct wl_surface;
struct MirConnection;
struct MirSurface;

namespace gapir {

class Vulkan : public Api {
public:
    // The unique identifier of the graphics API.
    static const char* ID;
    // The index of the graphics API.
    static uint8_t INDEX;

    // Constructor
    Vulkan();

    // Returns the unique identifier of the graphics API.
    const char* id() const override;
    // Returns the index of the graphics API.
    uint8_t index() const override;

    // Look-up the API function addresses for the graphics API.
    void resolve();

    enum class VkPipelineCacheHeaderVersion : uint32_t {
        VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
    };

    enum class VkResult : uint32_t {
        VK_SUCCESS = 0,
        VK_NOT_READY = 1,
        VK_TIMEOUT = 2,
        VK_EVENT_SET = 3,
        VK_EVENT_RESET = 4,
        VK_INCOMPLETE = 5,
        VK_ERROR_OUT_OF_HOST_MEMORY = 4294967295,
        VK_ERROR_OUT_OF_DEVICE_MEMORY = 4294967294,
        VK_ERROR_INITIALIZATION_FAILED = 4294967293,
        VK_ERROR_DEVICE_LOST = 4294967292,
        VK_ERROR_MEMORY_MAP_FAILED = 4294967291,
        VK_ERROR_LAYER_NOT_PRESENT = 4294967290,
        VK_ERROR_EXTENSION_NOT_PRESENT = 4294967289,
        VK_ERROR_FEATURE_NOT_PRESENT = 4294967288,
        VK_ERROR_INCOMPATIBLE_DRIVER = 4294967287,
        VK_ERROR_TOO_MANY_OBJECTS = 4294967286,
        VK_ERROR_FORMAT_NOT_SUPPORTED = 4294967285,
        VK_ERROR_SURFACE_LOST_KHR = 3294967296,
        VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = 3294967295,
        VK_SUBOPTIMAL_KHR = 1000001003,
        VK_ERROR_OUT_OF_DATE_KHR = 3294966292,
        VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = 3294964295,
        VK_ERROR_VALIDATION_FAILED_EXT = 3294956295,
        VK_ERROR_INVALID_SHADER_NV = 1000012000,
    };

    enum class VkStructureType : uint32_t {
        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,
        VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
        VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
        VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
        VK_STRUCTURE_TYPE_DISPLAY_DISPLAY_PRESENT_INFO_KHR = 1000003000,
        VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
        VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
        VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
        VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
        VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
        VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
        VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID = 1000010000,
        VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = 1000011000,
        VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
        VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
        VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
    };

    enum class VkSystemAllocationScope : uint32_t {
        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,
    };

    enum class VkInternalAllocationType : uint32_t {
        VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
    };

    enum class VkFormat : uint32_t {
        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,
    };

    enum class VkImageType : uint32_t {
        VK_IMAGE_TYPE_1D = 0,
        VK_IMAGE_TYPE_2D = 1,
        VK_IMAGE_TYPE_3D = 2,
    };

    enum class VkImageTiling : uint32_t {
        VK_IMAGE_TILING_OPTIMAL = 0,
        VK_IMAGE_TILING_LINEAR = 1,
    };

    enum class VkPhysicalDeviceType : uint32_t {
        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,
    };

    enum class VkQueryType : uint32_t {
        VK_QUERY_TYPE_OCCLUSION = 0,
        VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
        VK_QUERY_TYPE_TIMESTAMP = 2,
    };

    enum class VkSharingMode : uint32_t {
        VK_SHARING_MODE_EXCLUSIVE = 0,
        VK_SHARING_MODE_CONCURRENT = 1,
    };

    enum class VkImageLayout : uint32_t {
        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,
    };

    enum class VkImageViewType : uint32_t {
        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,
    };

    enum class VkComponentSwizzle : uint32_t {
        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,
    };

    enum class VkVertexInputRate : uint32_t {
        VK_VERTEX_INPUT_RATE_VERTEX = 0,
        VK_VERTEX_INPUT_RATE_INSTANCE = 1,
    };

    enum class VkPrimitiveTopology : uint32_t {
        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,
    };

    enum class VkPolygonMode : uint32_t {
        VK_POLYGON_MODE_FILL = 0,
        VK_POLYGON_MODE_LINE = 1,
        VK_POLYGON_MODE_POINT = 2,
    };

    enum class VkFrontFace : uint32_t {
        VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
        VK_FRONT_FACE_CLOCKWISE = 1,
    };

    enum class VkCompareOp : uint32_t {
        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,
    };

    enum class VkStencilOp : uint32_t {
        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,
    };

    enum class VkLogicOp : uint32_t {
        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,
    };

    enum class VkBlendFactor : uint32_t {
        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,
    };

    enum class VkBlendOp : uint32_t {
        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,
    };

    enum class VkDynamicState : uint32_t {
        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,
    };

    enum class VkFilter : uint32_t {
        VK_FILTER_NEAREST = 0,
        VK_FILTER_LINEAR = 1,
        VK_FILTER_CUBIC_IMG = 1000015000,
    };

    enum class VkSamplerMipmapMode : uint32_t {
        VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
        VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
    };

    enum class VkSamplerAddressMode : uint32_t {
        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,
        VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
    };

    enum class VkBorderColor : uint32_t {
        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,
    };

    enum class VkDescriptorType : uint32_t {
        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,
    };

    enum class VkAttachmentLoadOp : uint32_t {
        VK_ATTACHMENT_LOAD_OP_LOAD = 0,
        VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
        VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
    };

    enum class VkAttachmentStoreOp : uint32_t {
        VK_ATTACHMENT_STORE_OP_STORE = 0,
        VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
    };

    enum class VkPipelineBindPoint : uint32_t {
        VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
        VK_PIPELINE_BIND_POINT_COMPUTE = 1,
    };

    enum class VkCommandBufferLevel : uint32_t {
        VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
        VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
    };

    enum class VkIndexType : uint32_t {
        VK_INDEX_TYPE_UINT16 = 0,
        VK_INDEX_TYPE_UINT32 = 1,
    };

    enum class VkSubpassContents : uint32_t {
        VK_SUBPASS_CONTENTS_INLINE = 0,
        VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
    };

    enum class VkFormatFeatureFlagBits : uint32_t {
        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,
        VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 8192,
    };

    enum class VkImageUsageFlagBits : uint32_t {
        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,
    };

    enum class VkImageCreateFlagBits : uint32_t {
        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,
    };

    enum class VkSampleCountFlagBits : uint32_t {
        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,
    };

    enum class VkQueueFlagBits : uint32_t {
        VK_QUEUE_GRAPHICS_BIT = 1,
        VK_QUEUE_COMPUTE_BIT = 2,
        VK_QUEUE_TRANSFER_BIT = 4,
        VK_QUEUE_SPARSE_BINDING_BIT = 8,
    };

    enum class VkMemoryPropertyFlagBits : uint32_t {
        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,
    };

    enum class VkMemoryHeapFlagBits : uint32_t {
        VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1,
    };

    enum class VkPipelineStageFlagBits : uint32_t {
        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,
    };

    enum class VkImageAspectFlagBits : uint32_t {
        VK_IMAGE_ASPECT_COLOR_BIT = 1,
        VK_IMAGE_ASPECT_DEPTH_BIT = 2,
        VK_IMAGE_ASPECT_STENCIL_BIT = 4,
        VK_IMAGE_ASPECT_METADATA_BIT = 8,
    };

    enum class VkSparseImageFormatFlagBits : uint32_t {
        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,
    };

    enum class VkSparseMemoryBindFlagBits : uint32_t {
        VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1,
    };

    enum class VkFenceCreateFlagBits : uint32_t {
        VK_FENCE_CREATE_SIGNALED_BIT = 1,
    };

    enum class VkQueryPipelineStatisticFlagBits : uint32_t {
        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,
    };

    enum class VkQueryResultFlagBits : uint32_t {
        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,
    };

    enum class VkBufferCreateFlagBits : uint32_t {
        VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 1,
        VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 2,
        VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 4,
    };

    enum class VkBufferUsageFlagBits : uint32_t {
        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,
    };

    enum class VkPipelineCreateFlagBits : uint32_t {
        VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 1,
        VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 2,
        VK_PIPELINE_CREATE_DERIVATIVE_BIT = 4,
    };

    enum class VkShaderStageFlagBits : uint32_t {
        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_COMPUTE_BIT = 32,
        VK_SHADER_STAGE_ALL_GRAPHICS = 31,
        VK_SHADER_STAGE_ALL = 2147483647,
    };

    enum class VkCullModeFlagBits : uint32_t {
        VK_CULL_MODE_NONE = 0,
        VK_CULL_MODE_FRONT_BIT = 1,
        VK_CULL_MODE_BACK_BIT = 2,
        VK_CULL_MODE_FRONT_AND_BACK = 3,
    };

    enum class VkColorComponentFlagBits : uint32_t {
        VK_COLOR_COMPONENT_R_BIT = 1,
        VK_COLOR_COMPONENT_G_BIT = 2,
        VK_COLOR_COMPONENT_B_BIT = 4,
        VK_COLOR_COMPONENT_A_BIT = 8,
    };

    enum class VkDescriptorPoolCreateFlagBits : uint32_t {
        VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1,
    };

    enum class VkAttachmentDescriptionFlagBits : uint32_t {
        VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1,
    };

    enum class VkAccessFlagBits : uint32_t {
        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,
    };

    enum class VkDependencyFlagBits : uint32_t {
        VK_DEPENDENCY_BY_REGION_BIT = 1,
    };

    enum class VkCommandPoolCreateFlagBits : uint32_t {
        VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1,
        VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2,
    };

    enum class VkCommandPoolResetFlagBits : uint32_t {
        VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1,
    };

    enum class VkCommandBufferUsageFlagBits : uint32_t {
        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,
    };

    enum class VkQueryControlFlagBits : uint32_t {
        VK_QUERY_CONTROL_PRECISE_BIT = 1,
    };

    enum class VkCommandBufferResetFlagBits : uint32_t {
        VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1,
    };

    enum class VkStencilFaceFlagBits : uint32_t {
        VK_STENCIL_FACE_FRONT_BIT = 1,
        VK_STENCIL_FACE_BACK_BIT = 2,
        VK_STENCIL_FRONT_AND_BACK = 3,
    };

    enum class VkExternalMemoryHandleTypeFlagBitsNV : uint32_t {
        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,
    };

    enum class VkColorSpaceKHR : uint32_t {
        VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0,
    };

    enum class VkPresentModeKHR : uint32_t {
        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,
    };

    enum class VkSurfaceTransformFlagBitsKHR : uint32_t {
        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,
    };

    enum class VkCompositeAlphaFlagBitsKHR : uint32_t {
        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,
    };

    enum class VkDisplayPlaneAlphaFlagBitsKHR : uint32_t {
        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,
    };

    enum class VkDebugReportObjectTypeEXT : uint32_t {
        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_EXT = 28,
    };

    enum class VkDebugReportErrorEXT : uint32_t {
        VK_DEBUG_REPORT_ERROR_NONE_EXT = 0,
        VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1,
    };

    enum class VkDebugReportFlagBitsEXT : uint32_t {
        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,
    };

    typedef void* buffer_handle_t;
    typedef uint32_t VkFlags;
    typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
    typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
    typedef size_val Window;
    typedef size_val VisualID;
    typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
    typedef uint32_t xcb_window_t;
    typedef uint32_t xcb_visualid_t;
    typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
    typedef VkFlags VkMirSurfaceCreateFlagsKHR;
    typedef uint32_t VkBool32;
    typedef uint64_t VkDeviceSize;
    typedef uint32_t VkSampleMask;
    typedef size_val VkInstance;
    typedef size_val VkPhysicalDevice;
    typedef size_val VkDevice;
    typedef size_val VkQueue;
    typedef size_val VkCommandBuffer;
    typedef uint64_t VkSemaphore;
    typedef uint64_t VkFence;
    typedef uint64_t VkDeviceMemory;
    typedef uint64_t VkBuffer;
    typedef uint64_t VkImage;
    typedef uint64_t VkEvent;
    typedef uint64_t VkQueryPool;
    typedef uint64_t VkBufferView;
    typedef uint64_t VkImageView;
    typedef uint64_t VkShaderModule;
    typedef uint64_t VkPipelineCache;
    typedef uint64_t VkPipelineLayout;
    typedef uint64_t VkRenderPass;
    typedef uint64_t VkPipeline;
    typedef uint64_t VkDescriptorSetLayout;
    typedef uint64_t VkSampler;
    typedef uint64_t VkDescriptorPool;
    typedef uint64_t VkDescriptorSet;
    typedef uint64_t VkFramebuffer;
    typedef uint64_t VkCommandPool;
    typedef uint64_t VkSurfaceKHR;
    typedef uint64_t VkSwapchainKHR;
    typedef uint64_t VkDisplayKHR;
    typedef uint64_t VkDisplayModeKHR;
    typedef uint64_t VkDebugReportCallbackEXT;
    typedef VkFlags VkInstanceCreateFlags;
    typedef VkFlags VkFormatFeatureFlags;
    typedef VkFlags VkImageUsageFlags;
    typedef VkFlags VkImageCreateFlags;
    typedef VkFlags VkSampleCountFlags;
    typedef VkFlags VkQueueFlags;
    typedef VkFlags VkMemoryPropertyFlags;
    typedef VkFlags VkMemoryHeapFlags;
    typedef VkFlags VkDeviceCreateFlags;
    typedef VkFlags VkDeviceQueueCreateFlags;
    typedef VkFlags VkPipelineStageFlags;
    typedef VkFlags VkMemoryMapFlags;
    typedef VkFlags VkImageAspectFlags;
    typedef VkFlags VkSparseImageFormatFlags;
    typedef VkFlags VkSparseMemoryBindFlags;
    typedef VkFlags VkFenceCreateFlags;
    typedef VkFlags VkSemaphoreCreateFlags;
    typedef VkFlags VkEventCreateFlags;
    typedef VkFlags VkQueryPoolCreateFlags;
    typedef VkFlags VkQueryPipelineStatisticFlags;
    typedef VkFlags VkQueryResultFlags;
    typedef VkFlags VkBufferCreateFlags;
    typedef VkFlags VkBufferUsageFlags;
    typedef VkFlags VkBufferViewCreateFlags;
    typedef VkFlags VkImageViewCreateFlags;
    typedef VkFlags VkShaderModuleCreateFlags;
    typedef VkFlags VkPipelineCacheCreateFlags;
    typedef VkFlags VkPipelineCreateFlags;
    typedef VkFlags VkPipelineShaderStageCreateFlags;
    typedef VkFlags VkShaderStageFlags;
    typedef VkFlags VkPipelineVertexInputStateCreateFlags;
    typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
    typedef VkFlags VkPipelineTessellationStateCreateFlags;
    typedef VkFlags VkPipelineViewportStateCreateFlags;
    typedef VkFlags VkPipelineRasterizationStateCreateFlags;
    typedef VkFlags VkCullModeFlags;
    typedef VkFlags VkPipelineMultisampleStateCreateFlags;
    typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
    typedef VkFlags VkPipelineColorBlendStateCreateFlags;
    typedef VkFlags VkColorComponentFlags;
    typedef VkFlags VkPipelineDynamicStateCreateFlags;
    typedef VkFlags VkPipelineLayoutCreateFlags;
    typedef VkFlags VkSamplerCreateFlags;
    typedef VkFlags VkDescriptorSetLayoutCreateFlags;
    typedef VkFlags VkDescriptorPoolCreateFlags;
    typedef VkFlags VkDescriptorPoolResetFlags;
    typedef VkFlags VkFramebufferCreateFlags;
    typedef VkFlags VkRenderPassCreateFlags;
    typedef VkFlags VkAttachmentDescriptionFlags;
    typedef VkFlags VkSubpassDescriptionFlags;
    typedef VkFlags VkAccessFlags;
    typedef VkFlags VkDependencyFlags;
    typedef VkFlags VkCommandPoolCreateFlags;
    typedef VkFlags VkCommandPoolResetFlags;
    typedef VkFlags VkCommandBufferUsageFlags;
    typedef VkFlags VkQueryControlFlags;
    typedef VkFlags VkCommandBufferResetFlags;
    typedef VkFlags VkStencilFaceFlags;
    typedef void* PFN_vkAllocationFunction;
    typedef void* PFN_vkReallocationFunction;
    typedef void* PFN_vkFreeFunction;
    typedef void* PFN_vkInternalAllocationNotification;
    typedef void* PFN_vkInternalFreeNotification;
    typedef void* PFN_vkVoidFunction;
    typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
    typedef VkFlags VkSurfaceTransformFlagsKHR;
    typedef VkFlags VkCompositeAlphaFlagsKHR;
    typedef VkFlags VkSwapchainCreateFlagsKHR;
    typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
    typedef VkFlags VkDisplayModeCreateFlagsKHR;
    typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
    typedef VkFlags VkDebugReportFlagsEXT;
    typedef void* PFN_vkDebugReportCallbackEXT;
    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkAndroidSurfaceCreateFlagsKHR flags;
        ANativeWindow* window;
    } VkAndroidSurfaceCreateInfoKHR;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        buffer_handle_t handle;
        int stride;
        int format;
        int usage;
    } VkNativeBufferANDROID;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkXlibSurfaceCreateFlagsKHR flags;
        Display* dpy;
        Window window;
    } VkXlibSurfaceCreateInfoKHR;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkXcbSurfaceCreateFlagsKHR flags;
        xcb_connection_t* connection;
        xcb_window_t window;
    } VkXcbSurfaceCreateInfoKHR;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkWaylandSurfaceCreateFlagsKHR flags;
        wl_display* display;
        wl_surface* surface;
    } VkWaylandSurfaceCreateInfoKHR;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkMirSurfaceCreateFlagsKHR flags;
        MirConnection* connection;
        MirSurface* mirSurface;
    } VkMirSurfaceCreateInfoKHR;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        char* pApplicationName;
        uint32_t applicationVersion;
        char* pEngineName;
        uint32_t engineVersion;
        uint32_t apiVersion;
    } VkApplicationInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkInstanceCreateFlags flags;
        VkApplicationInfo* pApplicationInfo;
        uint32_t enabledLayerCount;
        char** ppEnabledLayerNames;
        uint32_t enabledExtensionCount;
        char** ppEnabledExtensionNames;
    } VkInstanceCreateInfo;

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

    typedef struct {
        VkBool32 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;
    } VkPhysicalDeviceFeatures;

    typedef struct {
        VkFormatFeatureFlags linearTilingFeatures;
        VkFormatFeatureFlags optimalTilingFeatures;
        VkFormatFeatureFlags bufferFeatures;
    } VkFormatProperties;

    typedef struct {
        uint32_t width;
        uint32_t height;
        uint32_t depth;
    } VkExtent3D;

    typedef struct {
        VkExtent3D maxExtent;
        uint32_t maxMipLevels;
        uint32_t maxArrayLayers;
        VkSampleCountFlags sampleCounts;
        VkDeviceSize maxResourceSize;
    } VkImageFormatProperties;

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

    typedef struct {
        VkBool32 residencyStandard2DBlockShape;
        VkBool32 residencyStandard2DMultisampleBlockShape;
        VkBool32 residencyStandard3DBlockShape;
        VkBool32 residencyAlignedMipSize;
        VkBool32 residencyNonResidentStrict;
    } VkPhysicalDeviceSparseProperties;

    typedef struct {
        uint32_t apiVersion;
        uint32_t driverVersion;
        uint32_t vendorID;
        uint32_t deviceID;
        VkPhysicalDeviceType deviceType;
        gapic::StaticArray<char, 256> deviceName;
        gapic::StaticArray<uint8_t, 16> pipelineCacheUUID;
        VkPhysicalDeviceLimits limits;
        VkPhysicalDeviceSparseProperties sparseProperties;
    } VkPhysicalDeviceProperties;

    typedef struct {
        VkQueueFlags queueFlags;
        uint32_t queueCount;
        uint32_t timestampValidBits;
        VkExtent3D minImageTransferGranularity;
    } VkQueueFamilyProperties;

    typedef struct {
        VkMemoryPropertyFlags propertyFlags;
        uint32_t heapIndex;
    } VkMemoryType;

    typedef struct {
        VkDeviceSize size;
        VkMemoryHeapFlags flags;
    } VkMemoryHeap;

    typedef struct {
        uint32_t memoryTypeCount;
        gapic::StaticArray<VkMemoryType, 32> memoryTypes;
        uint32_t memoryHeapCount;
        gapic::StaticArray<VkMemoryHeap, 16> memoryHeaps;
    } VkPhysicalDeviceMemoryProperties;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkDeviceQueueCreateFlags flags;
        uint32_t queueFamilyIndex;
        uint32_t queueCount;
        float* pQueuePriorities;
    } VkDeviceQueueCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkDeviceCreateFlags flags;
        uint32_t queueCreateInfoCount;
        VkDeviceQueueCreateInfo* pQueueCreateInfos;
        uint32_t enabledLayerCount;
        char** ppEnabledLayerNames;
        uint32_t enabledExtensionCount;
        char** ppEnabledExtensionNames;
        VkPhysicalDeviceFeatures* pEnabledFeatures;
    } VkDeviceCreateInfo;

    typedef struct {
        gapic::StaticArray<char, 256> extensionName;
        uint32_t specVersion;
    } VkExtensionProperties;

    typedef struct {
        gapic::StaticArray<char, 256> layerName;
        uint32_t specVersion;
        uint32_t implementationVersion;
        gapic::StaticArray<char, 256> description;
    } VkLayerProperties;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        uint32_t waitSemaphoreCount;
        VkSemaphore* pWaitSemaphores;
        VkPipelineStageFlags* pWaitDstStageMask;
        uint32_t commandBufferCount;
        VkCommandBuffer* pCommandBuffers;
        uint32_t signalSemaphoreCount;
        VkSemaphore* pSignalSemaphores;
    } VkSubmitInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkDeviceSize allocationSize;
        uint32_t memoryTypeIndex;
    } VkMemoryAllocateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkDeviceMemory memory;
        VkDeviceSize offset;
        VkDeviceSize size;
    } VkMappedMemoryRange;

    typedef struct {
        VkDeviceSize size;
        VkDeviceSize alignment;
        uint32_t memoryTypeBits;
    } VkMemoryRequirements;

    typedef struct {
        VkImageAspectFlagBits aspectMask;
        VkExtent3D imageGranularity;
        VkSparseImageFormatFlags flags;
    } VkSparseImageFormatProperties;

    typedef struct {
        VkSparseImageFormatProperties formatProperties;
        uint32_t imageMipTailFirstLod;
        VkDeviceSize imageMipTailSize;
        VkDeviceSize imageMipTailOffset;
        VkDeviceSize imageMipTailStride;
    } VkSparseImageMemoryRequirements;

    typedef struct {
        VkDeviceSize resourceOffset;
        VkDeviceSize size;
        VkDeviceMemory memory;
        VkDeviceSize memoryOffset;
        VkSparseMemoryBindFlags flags;
    } VkSparseMemoryBind;

    typedef struct {
        VkBuffer buffer;
        uint32_t bindCount;
        VkSparseMemoryBind* pBinds;
    } VkSparseBufferMemoryBindInfo;

    typedef struct {
        VkImage image;
        uint32_t bindCount;
        VkSparseMemoryBind* pBinds;
    } VkSparseImageOpaqueMemoryBindInfo;

    typedef struct {
        VkImageAspectFlagBits aspectMask;
        uint32_t mipLevel;
        uint32_t arrayLayer;
    } VkImageSubresource;

    typedef struct {
        int32_t x;
        int32_t y;
        int32_t z;
    } VkOffset3D;

    typedef struct {
        VkImageSubresource subresource;
        VkOffset3D offset;
        VkExtent3D extent;
        VkDeviceMemory memory;
        VkDeviceSize memoryOffset;
        VkSparseMemoryBindFlags flags;
    } VkSparseImageMemoryBind;

    typedef struct {
        VkImage image;
        uint32_t bindCount;
        VkSparseMemoryBind* pBinds;
    } VkSparseImageMemoryBindInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        uint32_t waitSemaphoreCount;
        VkSemaphore* pWaitSemaphores;
        uint32_t numBufferBinds;
        VkSparseBufferMemoryBindInfo* pBufferBinds;
        uint32_t numImageOpaqueBinds;
        VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
        uint32_t numImageBinds;
        VkSparseImageMemoryBindInfo* pImageBinds;
        uint32_t signalSemaphoreCount;
        VkSemaphore* pSignalSemaphores;
    } VkBindSparseInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkFenceCreateFlags flags;
    } VkFenceCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkSemaphoreCreateFlags flags;
    } VkSemaphoreCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkEventCreateFlags flags;
    } VkEventCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkQueryPoolCreateFlags flags;
        VkQueryType queryType;
        uint32_t queryCount;
        VkQueryPipelineStatisticFlags pipelineStatistics;
    } VkQueryPoolCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkBufferCreateFlags flags;
        VkDeviceSize size;
        VkBufferUsageFlags usage;
        VkSharingMode sharingMode;
        uint32_t queueFamilyIndexCount;
        uint32_t* pQueueFamilyIndices;
    } VkBufferCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkBufferViewCreateFlags flags;
        VkBuffer buffer;
        VkFormat format;
        VkDeviceSize offset;
        VkDeviceSize range;
    } VkBufferViewCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkImageCreateFlags flags;
        VkImageType imageType;
        VkFormat format;
        VkExtent3D extent;
        uint32_t mipLevels;
        uint32_t arrayLayers;
        VkSampleCountFlagBits samples;
        VkImageTiling tiling;
        VkImageUsageFlags usage;
        VkSharingMode sharingMode;
        uint32_t queueFamilyIndexCount;
        uint32_t* pQueueFamilyIndices;
        VkImageLayout initialLayout;
    } VkImageCreateInfo;

    typedef struct {
        VkDeviceSize offset;
        VkDeviceSize size;
        VkDeviceSize rowPitch;
        VkDeviceSize arrayPitch;
        VkDeviceSize depthPitch;
    } VkSubresourceLayout;

    typedef struct {
        VkComponentSwizzle r;
        VkComponentSwizzle g;
        VkComponentSwizzle b;
        VkComponentSwizzle a;
    } VkComponentMapping;

    typedef struct {
        VkImageAspectFlags aspectMask;
        uint32_t baseMipLevel;
        uint32_t levelCount;
        uint32_t baseArrayLayer;
        uint32_t layerCount;
    } VkImageSubresourceRange;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkImageViewCreateFlags flags;
        VkImage image;
        VkImageViewType viewType;
        VkFormat format;
        VkComponentMapping components;
        VkImageSubresourceRange subresourceRange;
    } VkImageViewCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkShaderModuleCreateFlags flags;
        size_val codeSize;
        uint32_t* pCode;
    } VkShaderModuleCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkPipelineCacheCreateFlags flags;
        size_val initialDataSize;
        void* pInitialData;
    } VkPipelineCacheCreateInfo;

    typedef struct {
        uint32_t constantID;
        uint32_t offset;
        size_val size;
    } VkSpecializationMapEntry;

    typedef struct {
        uint32_t mapEntryCount;
        VkSpecializationMapEntry* pMapEntries;
        size_val dataSize;
        void* pData;
    } VkSpecializationInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkPipelineShaderStageCreateFlags flags;
        VkShaderStageFlagBits stage;
        VkShaderModule module;
        char* pName;
        VkSpecializationInfo* pSpecializationInfo;
    } VkPipelineShaderStageCreateInfo;

    typedef struct {
        uint32_t binding;
        uint32_t stride;
        VkVertexInputRate inputRate;
    } VkVertexInputBindingDescription;

    typedef struct {
        uint32_t location;
        uint32_t binding;
        VkFormat format;
        uint32_t offset;
    } VkVertexInputAttributeDescription;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkPipelineVertexInputStateCreateFlags flags;
        uint32_t vertexBindingDescriptionCount;
        VkVertexInputBindingDescription* pVertexBindingDescriptions;
        uint32_t vertexAttributeDescriptionCount;
        VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
    } VkPipelineVertexInputStateCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkPipelineInputAssemblyStateCreateFlags flags;
        VkPrimitiveTopology topology;
        VkBool32 primitiveRestartEnable;
    } VkPipelineInputAssemblyStateCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkPipelineTessellationStateCreateFlags flags;
        uint32_t patchControlPoints;
    } VkPipelineTessellationStateCreateInfo;

    typedef struct {
        float x;
        float y;
        float width;
        float height;
        float minDepth;
        float maxDepth;
    } VkViewport;

    typedef struct {
        int32_t x;
        int32_t y;
    } VkOffset2D;

    typedef struct {
        uint32_t width;
        uint32_t height;
    } VkExtent2D;

    typedef struct {
        VkOffset2D offset;
        VkExtent2D extent;
    } VkRect2D;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkPipelineViewportStateCreateFlags flags;
        uint32_t viewportCount;
        VkViewport* pViewports;
        uint32_t scissorCount;
        VkRect2D* pScissors;
    } VkPipelineViewportStateCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkPipelineRasterizationStateCreateFlags flags;
        VkBool32 depthClampEnable;
        VkBool32 rasterizerDiscardEnable;
        VkPolygonMode polygonMode;
        VkCullModeFlags cullMode;
        VkFrontFace frontFace;
        VkBool32 depthBiasEnable;
        float depthBiasConstantFactor;
        float depthBiasClamp;
        float depthBiasSlopeFactor;
        float lineWidth;
    } VkPipelineRasterizationStateCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkPipelineMultisampleStateCreateFlags flags;
        VkSampleCountFlagBits rasterizationSamples;
        VkBool32 sampleShadingEnable;
        float minSampleShading;
        VkSampleMask* pSampleMask;
        VkBool32 alphaToCoverageEnable;
        VkBool32 alphaToOneEnable;
    } VkPipelineMultisampleStateCreateInfo;

    typedef struct {
        VkStencilOp failOp;
        VkStencilOp passOp;
        VkStencilOp depthFailOp;
        VkCompareOp compareOp;
        uint32_t compareMask;
        uint32_t writeMask;
        uint32_t reference;
    } VkStencilOpState;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkPipelineDepthStencilStateCreateFlags flags;
        VkBool32 depthTestEnable;
        VkBool32 depthWriteEnable;
        VkCompareOp depthCompareOp;
        VkBool32 depthBoundsTestEnable;
        VkBool32 stencilTestEnable;
        VkStencilOpState front;
        VkStencilOpState back;
        float minDepthBounds;
        float maxDepthBounds;
    } VkPipelineDepthStencilStateCreateInfo;

    typedef struct {
        VkBool32 blendEnable;
        VkBlendFactor srcColorBlendFactor;
        VkBlendFactor dstColorBlendFactor;
        VkBlendOp colorBlendOp;
        VkBlendFactor srcAlphaBlendFactor;
        VkBlendFactor dstAlphaBlendFactor;
        VkBlendOp alphaBlendOp;
        VkColorComponentFlags colorWriteMask;
    } VkPipelineColorBlendAttachmentState;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkPipelineColorBlendStateCreateFlags flags;
        VkBool32 logicOpEnable;
        VkLogicOp logicOp;
        uint32_t attachmentCount;
        VkPipelineColorBlendAttachmentState* pAttachments;
        gapic::StaticArray<float, 4> blendConstants;
    } VkPipelineColorBlendStateCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkPipelineDynamicStateCreateFlags flags;
        uint32_t dynamicStateCount;
        VkDynamicState* pDynamicStates;
    } VkPipelineDynamicStateCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkPipelineCreateFlags flags;
        uint32_t stageCount;
        VkPipelineShaderStageCreateInfo* pStages;
        VkPipelineVertexInputStateCreateInfo* pVertexInputState;
        VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
        VkPipelineTessellationStateCreateInfo* pTessellationState;
        VkPipelineViewportStateCreateInfo* pViewportState;
        VkPipelineRasterizationStateCreateInfo* pRasterizationState;
        VkPipelineMultisampleStateCreateInfo* pMultisampleState;
        VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
        VkPipelineColorBlendStateCreateInfo* pColorBlendState;
        VkPipelineDynamicStateCreateInfo* pDynamicState;
        VkPipelineLayout layout;
        VkRenderPass renderPass;
        uint32_t subpass;
        VkPipeline basePipelineHandle;
        int32_t basePipelineIndex;
    } VkGraphicsPipelineCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkPipelineCreateFlags flags;
        VkPipelineShaderStageCreateInfo stage;
        VkPipelineLayout layout;
        VkPipeline basePipelineHandle;
        int32_t basePipelineIndex;
    } VkComputePipelineCreateInfo;

    typedef struct {
        VkShaderStageFlags stageFlags;
        uint32_t offset;
        uint32_t size;
    } VkPushConstantRange;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkPipelineLayoutCreateFlags flags;
        uint32_t setLayoutCount;
        VkDescriptorSetLayout* pSetLayouts;
        uint32_t pushConstantRangeCount;
        VkPushConstantRange* pPushConstantRanges;
    } VkPipelineLayoutCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkSamplerCreateFlags flags;
        VkFilter magFilter;
        VkFilter minFilter;
        VkSamplerMipmapMode mipmapMode;
        VkSamplerAddressMode addressModeU;
        VkSamplerAddressMode addressModeV;
        VkSamplerAddressMode addressModeW;
        float mipLodBias;
        VkBool32 anisotropyEnable;
        float maxAnisotropy;
        VkBool32 compareEnable;
        VkCompareOp compareOp;
        float minLod;
        float maxLod;
        VkBorderColor borderColor;
        VkBool32 unnormalizedCoordinates;
    } VkSamplerCreateInfo;

    typedef struct {
        uint32_t binding;
        VkDescriptorType descriptorType;
        uint32_t descriptorCount;
        VkShaderStageFlags stageFlags;
        VkSampler* pImmutableSamplers;
    } VkDescriptorSetLayoutBinding;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkDescriptorSetLayoutCreateFlags flags;
        uint32_t bindingCount;
        VkDescriptorSetLayoutBinding* pBindings;
    } VkDescriptorSetLayoutCreateInfo;

    typedef struct {
        VkDescriptorType type;
        uint32_t descriptorCount;
    } VkDescriptorPoolSize;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkDescriptorPoolCreateFlags flags;
        uint32_t maxSets;
        uint32_t poolSizeCount;
        VkDescriptorPoolSize* pPoolSizes;
    } VkDescriptorPoolCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkDescriptorPool descriptorPool;
        uint32_t descriptorSetCount;
        VkDescriptorSetLayout* pSetLayouts;
    } VkDescriptorSetAllocateInfo;

    typedef struct {
        VkSampler sampler;
        VkImageView imageView;
        VkImageLayout imageLayout;
    } VkDescriptorImageInfo;

    typedef struct {
        VkBuffer buffer;
        VkDeviceSize offset;
        VkDeviceSize range;
    } VkDescriptorBufferInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkDescriptorSet dstSet;
        uint32_t dstBinding;
        uint32_t dstArrayElement;
        uint32_t descriptorCount;
        VkDescriptorType descriptorType;
        VkDescriptorImageInfo* pImageInfo;
        VkDescriptorBufferInfo* pBufferInfo;
        VkBufferView* pTexelBufferView;
    } VkWriteDescriptorSet;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkDescriptorSet srcSet;
        uint32_t srcBinding;
        uint32_t srcArrayElement;
        VkDescriptorSet dstSet;
        uint32_t dstBinding;
        uint32_t dstArrayElement;
        uint32_t descriptorCount;
    } VkCopyDescriptorSet;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkFramebufferCreateFlags flags;
        VkRenderPass renderPass;
        uint32_t attachmentCount;
        VkImageView* pAttachments;
        uint32_t width;
        uint32_t height;
        uint32_t layers;
    } VkFramebufferCreateInfo;

    typedef struct {
        VkAttachmentDescriptionFlags flags;
        VkFormat format;
        VkSampleCountFlagBits samples;
        VkAttachmentLoadOp loadOp;
        VkAttachmentStoreOp storeOp;
        VkAttachmentLoadOp stencilLoadOp;
        VkAttachmentStoreOp stencilStoreOp;
        VkImageLayout initialLayout;
        VkImageLayout finalLayout;
    } VkAttachmentDescription;

    typedef struct {
        uint32_t attachment;
        VkImageLayout layout;
    } VkAttachmentReference;

    typedef struct {
        VkSubpassDescriptionFlags flags;
        VkPipelineBindPoint pipelineBindPoint;
        uint32_t inputAttachmentCount;
        VkAttachmentReference* pInputAttachments;
        uint32_t colorAttachmentCount;
        VkAttachmentReference* pColorAttachments;
        VkAttachmentReference* pResolveAttachments;
        VkAttachmentReference* pDepthStencilAttachment;
        uint32_t preserveAttachmentCount;
        uint32_t* pPreserveAttachments;
    } VkSubpassDescription;

    typedef struct {
        uint32_t srcSubpass;
        uint32_t dstSubpass;
        VkPipelineStageFlags srcStageMask;
        VkPipelineStageFlags dstStageMask;
        VkAccessFlags srcAccessMask;
        VkAccessFlags dstAccessMask;
        VkDependencyFlags dependencyFlags;
    } VkSubpassDependency;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkRenderPassCreateFlags flags;
        uint32_t attachmentCount;
        VkAttachmentDescription* pAttachments;
        uint32_t subpassCount;
        VkSubpassDescription* pSubpasses;
        uint32_t dependencyCount;
        VkSubpassDependency* pDependencies;
    } VkRenderPassCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkCommandPoolCreateFlags flags;
        uint32_t queueFamilyIndex;
    } VkCommandPoolCreateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkCommandPool commandPool;
        VkCommandBufferLevel level;
        uint32_t commandBufferCount;
    } VkCommandBufferAllocateInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkRenderPass renderPass;
        uint32_t subpass;
        VkFramebuffer framebuffer;
        VkBool32 occlusionQueryEnable;
        VkQueryControlFlags queryFlags;
        VkQueryPipelineStatisticFlags pipelineStatistics;
    } VkCommandBufferInheritanceInfo;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkCommandBufferUsageFlags flags;
        VkCommandBufferInheritanceInfo* pInheritanceInfo;
    } VkCommandBufferBeginInfo;

    typedef struct {
        VkDeviceSize srcOffset;
        VkDeviceSize dstOffset;
        VkDeviceSize size;
    } VkBufferCopy;

    typedef struct {
        VkImageAspectFlags aspectMask;
        uint32_t mipLevel;
        uint32_t baseArrayLayer;
        uint32_t layerCount;
    } VkImageSubresourceLayers;

    typedef struct {
        VkImageSubresourceLayers srcSubresource;
        VkOffset3D srcOffset;
        VkImageSubresourceLayers dstSubresource;
        VkOffset3D dstOffset;
        VkExtent3D extent;
    } VkImageCopy;

    typedef struct {
        VkImageSubresourceLayers srcSubresource;
        gapic::StaticArray<VkOffset3D, 2> srcOffsets;
        VkImageSubresourceLayers dstSubresource;
        gapic::StaticArray<VkOffset3D, 2> dstOffsets;
    } VkImageBlit;

    typedef struct {
        VkDeviceSize bufferOffset;
        uint32_t bufferRowLength;
        uint32_t bufferImageHeight;
        VkImageSubresourceLayers imageSubresource;
        VkOffset3D imageOffset;
        VkExtent3D imageExtent;
    } VkBufferImageCopy;

    typedef struct {
        gapic::StaticArray<uint32_t, 4> uint32;
    } VkClearColorValue;

    typedef struct {
        float depth;
        uint32_t stencil;
    } VkClearDepthStencilValue;

    typedef struct {
        VkClearColorValue color;
    } VkClearValue;

    typedef struct {
        VkImageAspectFlags aspectMask;
        uint32_t colorAttachment;
        VkClearValue clearValue;
    } VkClearAttachment;

    typedef struct {
        VkRect2D rect;
        uint32_t baseArrayLayer;
        uint32_t layerCount;
    } VkClearRect;

    typedef struct {
        VkImageSubresourceLayers srcSubresource;
        VkOffset3D srcOffset;
        VkImageSubresourceLayers dstSubresource;
        VkOffset3D dstOffset;
        VkExtent3D extent;
    } VkImageResolve;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkAccessFlags srcAccessMask;
        VkAccessFlags dstAccessMask;
    } VkMemoryBarrier;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkAccessFlags srcAccessMask;
        VkAccessFlags dstAccessMask;
        uint32_t srcQueueFamilyIndex;
        uint32_t dstQueueFamilyIndex;
        VkBuffer buffer;
        VkDeviceSize offset;
        VkDeviceSize size;
    } VkBufferMemoryBarrier;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkAccessFlags srcAccessMask;
        VkAccessFlags dstAccessMask;
        VkImageLayout oldLayout;
        VkImageLayout newLayout;
        uint32_t srcQueueFamilyIndex;
        uint32_t dstQueueFamilyIndex;
        VkImage image;
        VkImageSubresourceRange subresourceRange;
    } VkImageMemoryBarrier;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkRenderPass renderPass;
        VkFramebuffer framebuffer;
        VkRect2D renderArea;
        uint32_t clearValueCount;
        VkClearValue* pClearValues;
    } VkRenderPassBeginInfo;

    typedef struct {
        uint32_t x;
        uint32_t y;
        uint32_t z;
    } VkDispatchIndirectCommand;

    typedef struct {
        uint32_t indexCount;
        uint32_t instanceCount;
        uint32_t firstIndex;
        int32_t vertexOffset;
        uint32_t firstInstance;
    } VkDrawIndexedIndirectCommand;

    typedef struct {
        uint32_t vertexCount;
        uint32_t instanceCount;
        uint32_t firstVertex;
        uint32_t firstInstance;
    } VkDrawIndirectCommand;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkBool32 dedicatedAllocation;
    } VkDedicatedAllocationImageCreateInfoNV;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkBool32 dedicatedAllocation;
    } VkDedicatedAllocationBufferCreateInfoNV;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkImage image;
        VkBuffer buffer;
    } VkDedicatedAllocationMemoryAllocateInfoNV;

    typedef struct {
        VkPipelineBindPoint PipelineBindPoint;
        VkPipeline Pipeline;
    } CmdBindPipeline;

    typedef struct {
        VkFramebuffer Framebuffer;
    } CmdBeginRenderPass;

    typedef struct {
        uint32_t minImageCount;
        uint32_t maxImageCount;
        VkExtent2D currentExtent;
        VkExtent2D minImageExtent;
        VkExtent2D maxImageExtent;
        uint32_t maxImageArrayLayers;
        VkSurfaceTransformFlagsKHR supportedTransforms;
        VkSurfaceTransformFlagBitsKHR currentTransform;
        VkCompositeAlphaFlagsKHR supportedCompositeAlpha;
        VkImageUsageFlags supportedUsageFlags;
    } VkSurfaceCapabilitiesKHR;

    typedef struct {
        VkFormat format;
        VkColorSpaceKHR colorSpace;
    } VkSurfaceFormatKHR;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkSwapchainCreateFlagsKHR flags;
        VkSurfaceKHR surface;
        uint32_t minImageCount;
        VkFormat imageFormat;
        VkColorSpaceKHR imageColorSpace;
        VkExtent2D imageExtent;
        uint32_t imageArrayLayers;
        VkImageUsageFlags imageUsage;
        VkSharingMode imageSharingMode;
        uint32_t queueFamilyIndexCount;
        uint32_t* pQueueFamilyIndices;
        VkSurfaceTransformFlagBitsKHR preTransform;
        VkCompositeAlphaFlagBitsKHR compositeAlpha;
        VkPresentModeKHR presentMode;
        VkBool32 clipped;
        VkSwapchainKHR oldSwapchain;
    } VkSwapchainCreateInfoKHR;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        uint32_t waitSemaphoreCount;
        VkSemaphore* pWaitSemaphores;
        uint32_t swapchainCount;
        VkSwapchainKHR* pSwapchains;
        uint32_t* pImageIndices;
        VkResult* pResults;
    } VkPresentInfoKHR;

    typedef struct {
        VkDisplayKHR display;
        std::string displayName;
        VkExtent2D physicalDimensions;
        VkExtent2D physicalResolution;
        VkSurfaceTransformFlagsKHR supportedTransforms;
        VkBool32 planeReorderPossible;
        VkBool32 persistentContent;
    } VkDisplayPropertiesKHR;

    typedef struct {
        VkExtent2D visibleRegion;
        uint32_t refreshRate;
    } VkDisplayModeParametersKHR;

    typedef struct {
        VkDisplayModeKHR displayMode;
        VkDisplayModeParametersKHR parameters;
    } VkDisplayModePropertiesKHR;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkDisplayModeCreateFlagsKHR flags;
        VkDisplayModeParametersKHR parameters;
    } VkDisplayModeCreateInfoKHR;

    typedef struct {
        VkDisplayPlaneAlphaFlagsKHR supportedAlpha;
        VkOffset2D minSrcPosition;
        VkOffset2D maxSrcPosition;
        VkExtent2D minSrcExtent;
        VkExtent2D maxSrcExtent;
        VkOffset2D minDstPosition;
        VkOffset2D maxDstPosition;
        VkExtent2D minDstExtent;
        VkExtent2D maxDstExtent;
    } VkDisplayPlaneCapabilitiesKHR;

    typedef struct {
        VkDisplayKHR currentDisplay;
        uint32_t currentStackIndex;
    } VkDisplayPlanePropertiesKHR;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkDisplaySurfaceCreateFlagsKHR flags;
        VkDisplayModeKHR displayMode;
        uint32_t planeIndex;
        uint32_t planeStackIndex;
        VkSurfaceTransformFlagBitsKHR transform;
        float globalAlpha;
        VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
        VkExtent2D imageExtent;
    } VkDisplaySurfaceCreateInfoKHR;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkRect2D srcRect;
        VkRect2D dstRect;
        VkBool32 persistent;
    } VkDisplayPresentInfoKHR;

    typedef struct {
        VkStructureType sType;
        void* pNext;
        VkDebugReportFlagsEXT flags;
        PFN_vkDebugReportCallbackEXT pfnCallback;
        void* pUserData;
    } VkDebugReportCallbackCreateInfoEXT;


    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEANDROIDSURFACEKHR)(VkInstance instance, VkAndroidSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
    typedef VkResult (VULKAN_API_PTR *PFNVKGETSWAPCHAINGRALLOCUSAGEANDROID)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
    typedef VkResult (VULKAN_API_PTR *PFNVKACQUIREIMAGEANDROID)(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence);
    typedef VkResult (VULKAN_API_PTR *PFNVKQUEUESIGNALRELEASEIMAGEANDROID)(VkQueue queue, uint32_t waitSemaphoreCount, VkSemaphore* pWaitSemaphores, VkImage image, int* pNativeFenceFd);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEXLIBSURFACEKHR)(VkInstance instance, VkXlibSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
    typedef VkBool32 (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEXLIBPRESENTATIONSUPPORTKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEXCBSURFACEKHR)(VkInstance instance, VkXcbSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
    typedef VkBool32 (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEXCBPRESENTATIONSUPPORTKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEWAYLANDSURFACEKHR)(VkInstance instance, VkWaylandSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
    typedef VkBool32 (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEWAYLANDPRESENTATIONSUPPORTKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, wl_display* display);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEMIRSURFACEKHR)(VkInstance instance, VkMirSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
    typedef VkBool32 (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEMIRPRESENTATIONSUPPORTKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
    typedef void* (VULKAN_API_PTR *PFNVKALLOCATIONFUNCTION)(void* pUserData, size_val size, size_val alignment, VkSystemAllocationScope allocationScope);
    typedef void* (VULKAN_API_PTR *PFNVKREALLOCATIONFUNCTION)(void* pUserData, void* pOriginal, size_val size, size_val alignment, VkSystemAllocationScope allocationScope);
    typedef void (VULKAN_API_PTR *PFNVKFREEFUNCTION)(void* pUserData, void* pMemory);
    typedef void (VULKAN_API_PTR *PFNVKINTERNALALLOCATIONNOTIFICATION)(void* pUserData, size_val size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope);
    typedef void (VULKAN_API_PTR *PFNVKINTERNALFREENOTIFICATION)(void* pUserData, size_val size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope);
    typedef void (VULKAN_API_PTR *PFNVKVOIDFUNCTION)();
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEINSTANCE)(VkInstanceCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYINSTANCE)(VkInstance instance, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKENUMERATEPHYSICALDEVICES)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
    typedef void (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEFEATURES)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
    typedef void (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEFORMATPROPERTIES)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
    typedef VkResult (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEIMAGEFORMATPROPERTIES)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
    typedef void (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEPROPERTIES)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
    typedef void (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEQUEUEFAMILYPROPERTIES)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
    typedef void (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEMEMORYPROPERTIES)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
    typedef PFN_vkVoidFunction (VULKAN_API_PTR *PFNVKGETINSTANCEPROCADDR)(VkInstance instance, const char* pName);
    typedef PFN_vkVoidFunction (VULKAN_API_PTR *PFNVKGETDEVICEPROCADDR)(VkDevice device, const char* pName);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEDEVICE)(VkPhysicalDevice physicalDevice, VkDeviceCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYDEVICE)(VkDevice device, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKENUMERATEINSTANCEEXTENSIONPROPERTIES)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
    typedef VkResult (VULKAN_API_PTR *PFNVKENUMERATEDEVICEEXTENSIONPROPERTIES)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
    typedef VkResult (VULKAN_API_PTR *PFNVKENUMERATEINSTANCELAYERPROPERTIES)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
    typedef VkResult (VULKAN_API_PTR *PFNVKENUMERATEDEVICELAYERPROPERTIES)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
    typedef void (VULKAN_API_PTR *PFNVKGETDEVICEQUEUE)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
    typedef VkResult (VULKAN_API_PTR *PFNVKQUEUESUBMIT)(VkQueue queue, uint32_t submitCount, VkSubmitInfo* pSubmits, VkFence fence);
    typedef VkResult (VULKAN_API_PTR *PFNVKQUEUEWAITIDLE)(VkQueue queue);
    typedef VkResult (VULKAN_API_PTR *PFNVKDEVICEWAITIDLE)(VkDevice device);
    typedef VkResult (VULKAN_API_PTR *PFNVKALLOCATEMEMORY)(VkDevice device, VkMemoryAllocateInfo* pAllocateInfo, VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
    typedef void (VULKAN_API_PTR *PFNVKFREEMEMORY)(VkDevice device, VkDeviceMemory memory, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKMAPMEMORY)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
    typedef void (VULKAN_API_PTR *PFNVKUNMAPMEMORY)(VkDevice device, VkDeviceMemory memory);
    typedef VkResult (VULKAN_API_PTR *PFNVKFLUSHMAPPEDMEMORYRANGES)(VkDevice device, uint32_t memoryRangeCount, VkMappedMemoryRange* pMemoryRanges);
    typedef VkResult (VULKAN_API_PTR *PFNVKINVALIDATEMAPPEDMEMORYRANGES)(VkDevice device, uint32_t memoryRangeCount, VkMappedMemoryRange* pMemoryRanges);
    typedef void (VULKAN_API_PTR *PFNVKGETDEVICEMEMORYCOMMITMENT)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
    typedef VkResult (VULKAN_API_PTR *PFNVKBINDBUFFERMEMORY)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
    typedef VkResult (VULKAN_API_PTR *PFNVKBINDIMAGEMEMORY)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
    typedef void (VULKAN_API_PTR *PFNVKGETBUFFERMEMORYREQUIREMENTS)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
    typedef void (VULKAN_API_PTR *PFNVKGETIMAGEMEMORYREQUIREMENTS)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
    typedef void (VULKAN_API_PTR *PFNVKGETIMAGESPARSEMEMORYREQUIREMENTS)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
    typedef void (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICESPARSEIMAGEFORMATPROPERTIES)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
    typedef VkResult (VULKAN_API_PTR *PFNVKQUEUEBINDSPARSE)(VkQueue queue, uint32_t bindInfoCount, VkBindSparseInfo* pBindInfo, VkFence fence);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEFENCE)(VkDevice device, VkFenceCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkFence* pFence);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYFENCE)(VkDevice device, VkFence fence, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKRESETFENCES)(VkDevice device, uint32_t fenceCount, VkFence* pFences);
    typedef VkResult (VULKAN_API_PTR *PFNVKGETFENCESTATUS)(VkDevice device, VkFence fence);
    typedef VkResult (VULKAN_API_PTR *PFNVKWAITFORFENCES)(VkDevice device, uint32_t fenceCount, VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATESEMAPHORE)(VkDevice device, VkSemaphoreCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYSEMAPHORE)(VkDevice device, VkSemaphore semaphore, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEEVENT)(VkDevice device, VkEventCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYEVENT)(VkDevice device, VkEvent event, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKGETEVENTSTATUS)(VkDevice device, VkEvent event);
    typedef VkResult (VULKAN_API_PTR *PFNVKSETEVENT)(VkDevice device, VkEvent event);
    typedef VkResult (VULKAN_API_PTR *PFNVKRESETEVENT)(VkDevice device, VkEvent event);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEQUERYPOOL)(VkDevice device, VkQueryPoolCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYQUERYPOOL)(VkDevice device, VkQueryPool queryPool, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKGETQUERYPOOLRESULTS)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_val dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEBUFFER)(VkDevice device, VkBufferCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYBUFFER)(VkDevice device, VkBuffer buffer, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEBUFFERVIEW)(VkDevice device, VkBufferViewCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkBufferView* pView);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYBUFFERVIEW)(VkDevice device, VkBufferView bufferView, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEIMAGE)(VkDevice device, VkImageCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkImage* pImage);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYIMAGE)(VkDevice device, VkImage image, VkAllocationCallbacks* pAllocator);
    typedef void (VULKAN_API_PTR *PFNVKGETIMAGESUBRESOURCELAYOUT)(VkDevice device, VkImage image, VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEIMAGEVIEW)(VkDevice device, VkImageViewCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkImageView* pView);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYIMAGEVIEW)(VkDevice device, VkImageView imageView, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATESHADERMODULE)(VkDevice device, VkShaderModuleCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYSHADERMODULE)(VkDevice device, VkShaderModule shaderModule, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEPIPELINECACHE)(VkDevice device, VkPipelineCacheCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYPIPELINECACHE)(VkDevice device, VkPipelineCache pipelineCache, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKGETPIPELINECACHEDATA)(VkDevice device, VkPipelineCache pipelineCache, size_val* pDataSize, void* pData);
    typedef VkResult (VULKAN_API_PTR *PFNVKMERGEPIPELINECACHES)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, VkPipelineCache* pSrcCaches);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEGRAPHICSPIPELINES)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, VkGraphicsPipelineCreateInfo* pCreateInfos, VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATECOMPUTEPIPELINES)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, VkComputePipelineCreateInfo* pCreateInfos, VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYPIPELINE)(VkDevice device, VkPipeline pipeline, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEPIPELINELAYOUT)(VkDevice device, VkPipelineLayoutCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYPIPELINELAYOUT)(VkDevice device, VkPipelineLayout pipelineLayout, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATESAMPLER)(VkDevice device, VkSamplerCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYSAMPLER)(VkDevice device, VkSampler sampler, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEDESCRIPTORSETLAYOUT)(VkDevice device, VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYDESCRIPTORSETLAYOUT)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEDESCRIPTORPOOL)(VkDevice device, VkDescriptorPoolCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYDESCRIPTORPOOL)(VkDevice device, VkDescriptorPool descriptorPool, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKRESETDESCRIPTORPOOL)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
    typedef VkResult (VULKAN_API_PTR *PFNVKALLOCATEDESCRIPTORSETS)(VkDevice device, VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
    typedef VkResult (VULKAN_API_PTR *PFNVKFREEDESCRIPTORSETS)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, VkDescriptorSet* pDescriptorSets);
    typedef void (VULKAN_API_PTR *PFNVKUPDATEDESCRIPTORSETS)(VkDevice device, uint32_t descriptorWriteCount, VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, VkCopyDescriptorSet* pDescriptorCopies);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEFRAMEBUFFER)(VkDevice device, VkFramebufferCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYFRAMEBUFFER)(VkDevice device, VkFramebuffer framebuffer, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATERENDERPASS)(VkDevice device, VkRenderPassCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYRENDERPASS)(VkDevice device, VkRenderPass renderPass, VkAllocationCallbacks* pAllocator);
    typedef void (VULKAN_API_PTR *PFNVKGETRENDERAREAGRANULARITY)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATECOMMANDPOOL)(VkDevice device, VkCommandPoolCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYCOMMANDPOOL)(VkDevice device, VkCommandPool commandPool, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKRESETCOMMANDPOOL)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
    typedef VkResult (VULKAN_API_PTR *PFNVKALLOCATECOMMANDBUFFERS)(VkDevice device, VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
    typedef void (VULKAN_API_PTR *PFNVKFREECOMMANDBUFFERS)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, VkCommandBuffer* pCommandBuffers);
    typedef VkResult (VULKAN_API_PTR *PFNVKBEGINCOMMANDBUFFER)(VkCommandBuffer commandBuffer, VkCommandBufferBeginInfo* pBeginInfo);
    typedef VkResult (VULKAN_API_PTR *PFNVKENDCOMMANDBUFFER)(VkCommandBuffer commandBuffer);
    typedef VkResult (VULKAN_API_PTR *PFNVKRESETCOMMANDBUFFER)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
    typedef void (VULKAN_API_PTR *PFNVKCMDBINDPIPELINE)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
    typedef void (VULKAN_API_PTR *PFNVKCMDSETVIEWPORT)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, VkViewport* pViewports);
    typedef void (VULKAN_API_PTR *PFNVKCMDSETSCISSOR)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, VkRect2D* pScissors);
    typedef void (VULKAN_API_PTR *PFNVKCMDSETLINEWIDTH)(VkCommandBuffer commandBuffer, float lineWidth);
    typedef void (VULKAN_API_PTR *PFNVKCMDSETDEPTHBIAS)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
    typedef void (VULKAN_API_PTR *PFNVKCMDSETBLENDCONSTANTS)(VkCommandBuffer commandBuffer, float blendConstants[4]);
    typedef void (VULKAN_API_PTR *PFNVKCMDSETDEPTHBOUNDS)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
    typedef void (VULKAN_API_PTR *PFNVKCMDSETSTENCILCOMPAREMASK)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
    typedef void (VULKAN_API_PTR *PFNVKCMDSETSTENCILWRITEMASK)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
    typedef void (VULKAN_API_PTR *PFNVKCMDSETSTENCILREFERENCE)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
    typedef void (VULKAN_API_PTR *PFNVKCMDBINDDESCRIPTORSETS)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, uint32_t* pDynamicOffsets);
    typedef void (VULKAN_API_PTR *PFNVKCMDBINDINDEXBUFFER)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
    typedef void (VULKAN_API_PTR *PFNVKCMDBINDVERTEXBUFFERS)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, VkBuffer* pBuffers, VkDeviceSize* pOffsets);
    typedef void (VULKAN_API_PTR *PFNVKCMDDRAW)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
    typedef void (VULKAN_API_PTR *PFNVKCMDDRAWINDEXED)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
    typedef void (VULKAN_API_PTR *PFNVKCMDDRAWINDIRECT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
    typedef void (VULKAN_API_PTR *PFNVKCMDDRAWINDEXEDINDIRECT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
    typedef void (VULKAN_API_PTR *PFNVKCMDDISPATCH)(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z);
    typedef void (VULKAN_API_PTR *PFNVKCMDDISPATCHINDIRECT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
    typedef void (VULKAN_API_PTR *PFNVKCMDCOPYBUFFER)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, VkBufferCopy* pRegions);
    typedef void (VULKAN_API_PTR *PFNVKCMDCOPYIMAGE)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, VkImageCopy* pRegions);
    typedef void (VULKAN_API_PTR *PFNVKCMDBLITIMAGE)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, VkImageBlit* pRegions, VkFilter filter);
    typedef void (VULKAN_API_PTR *PFNVKCMDCOPYBUFFERTOIMAGE)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, VkBufferImageCopy* pRegions);
    typedef void (VULKAN_API_PTR *PFNVKCMDCOPYIMAGETOBUFFER)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, VkBufferImageCopy* pRegions);
    typedef void (VULKAN_API_PTR *PFNVKCMDUPDATEBUFFER)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, void* pData);
    typedef void (VULKAN_API_PTR *PFNVKCMDFILLBUFFER)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
    typedef void (VULKAN_API_PTR *PFNVKCMDCLEARCOLORIMAGE)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearColorValue* pColor, uint32_t rangeCount, VkImageSubresourceRange* pRanges);
    typedef void (VULKAN_API_PTR *PFNVKCMDCLEARDEPTHSTENCILIMAGE)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, VkImageSubresourceRange* pRanges);
    typedef void (VULKAN_API_PTR *PFNVKCMDCLEARATTACHMENTS)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, VkClearAttachment* pAttachments, uint32_t rectCount, VkClearRect* pRects);
    typedef void (VULKAN_API_PTR *PFNVKCMDRESOLVEIMAGE)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, VkImageResolve* pRegions);
    typedef void (VULKAN_API_PTR *PFNVKCMDSETEVENT)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
    typedef void (VULKAN_API_PTR *PFNVKCMDRESETEVENT)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
    typedef void (VULKAN_API_PTR *PFNVKCMDWAITEVENTS)(VkCommandBuffer commandBuffer, uint32_t eventCount, VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, VkImageMemoryBarrier* pImageMemoryBarriers);
    typedef void (VULKAN_API_PTR *PFNVKCMDPIPELINEBARRIER)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, VkImageMemoryBarrier* pImageMemoryBarriers);
    typedef void (VULKAN_API_PTR *PFNVKCMDBEGINQUERY)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
    typedef void (VULKAN_API_PTR *PFNVKCMDENDQUERY)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
    typedef void (VULKAN_API_PTR *PFNVKCMDRESETQUERYPOOL)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
    typedef void (VULKAN_API_PTR *PFNVKCMDWRITETIMESTAMP)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
    typedef void (VULKAN_API_PTR *PFNVKCMDCOPYQUERYPOOLRESULTS)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
    typedef void (VULKAN_API_PTR *PFNVKCMDPUSHCONSTANTS)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, void* pValues);
    typedef void (VULKAN_API_PTR *PFNVKCMDBEGINRENDERPASS)(VkCommandBuffer commandBuffer, VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
    typedef void (VULKAN_API_PTR *PFNVKCMDNEXTSUBPASS)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
    typedef void (VULKAN_API_PTR *PFNVKCMDENDRENDERPASS)(VkCommandBuffer commandBuffer);
    typedef void (VULKAN_API_PTR *PFNVKCMDEXECUTECOMMANDS)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, VkCommandBuffer* pCommandBuffers);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYSURFACEKHR)(VkInstance instance, VkSurfaceKHR surface, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICESURFACESUPPORTKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
    typedef VkResult (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICESURFACECAPABILITIESKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
    typedef VkResult (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICESURFACEFORMATSKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
    typedef VkResult (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICESURFACEPRESENTMODESKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATESWAPCHAINKHR)(VkDevice device, VkSwapchainCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYSWAPCHAINKHR)(VkDevice device, VkSwapchainKHR swapchain, VkAllocationCallbacks* pAllocator);
    typedef VkResult (VULKAN_API_PTR *PFNVKGETSWAPCHAINIMAGESKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
    typedef VkResult (VULKAN_API_PTR *PFNVKACQUIRENEXTIMAGEKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
    typedef VkResult (VULKAN_API_PTR *PFNVKQUEUEPRESENTKHR)(VkQueue queue, VkPresentInfoKHR* pPresentInfo);
    typedef VkResult (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEDISPLAYPROPERTIESKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
    typedef VkResult (VULKAN_API_PTR *PFNVKGETPHYSICALDEVICEDISPLAYPLANEPROPERTIESKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
    typedef VkResult (VULKAN_API_PTR *PFNVKGETDISPLAYPLANESUPPORTEDDISPLAYSKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
    typedef VkResult (VULKAN_API_PTR *PFNVKGETDISPLAYMODEPROPERTIESKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEDISPLAYMODEKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, VkDisplayModeCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
    typedef VkResult (VULKAN_API_PTR *PFNVKGETDISPLAYPLANECAPABILITIESKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEDISPLAYPLANESURFACEKHR)(VkInstance instance, VkDisplaySurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATESHAREDSWAPCHAINSKHR)(VkDevice device, uint32_t swapchainCount, VkSwapchainCreateInfoKHR* pCreateInfos, VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
    typedef VkBool32 (VULKAN_API_PTR *PFNVKDEBUGREPORTCALLBACKEXT)(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_val location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData);
    typedef VkResult (VULKAN_API_PTR *PFNVKCREATEDEBUGREPORTCALLBACKEXT)(VkInstance instance, VkDebugReportCallbackCreateInfoEXT* pCreateInfo, VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
    typedef void (VULKAN_API_PTR *PFNVKDESTROYDEBUGREPORTCALLBACKEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, VkAllocationCallbacks* pAllocator);
    typedef void (VULKAN_API_PTR *PFNVKDEBUGREPORTMESSAGEEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_val location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage);

    struct VkInstanceFunctionStubs {
        PFNVKCREATEANDROIDSURFACEKHR vkCreateAndroidSurfaceKHR = nullptr;
        PFNVKCREATEXLIBSURFACEKHR vkCreateXlibSurfaceKHR = nullptr;
        PFNVKGETPHYSICALDEVICEXLIBPRESENTATIONSUPPORTKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = nullptr;
        PFNVKCREATEXCBSURFACEKHR vkCreateXcbSurfaceKHR = nullptr;
        PFNVKGETPHYSICALDEVICEXCBPRESENTATIONSUPPORTKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = nullptr;
        PFNVKCREATEWAYLANDSURFACEKHR vkCreateWaylandSurfaceKHR = nullptr;
        PFNVKGETPHYSICALDEVICEWAYLANDPRESENTATIONSUPPORTKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = nullptr;
        PFNVKCREATEMIRSURFACEKHR vkCreateMirSurfaceKHR = nullptr;
        PFNVKGETPHYSICALDEVICEMIRPRESENTATIONSUPPORTKHR vkGetPhysicalDeviceMirPresentationSupportKHR = nullptr;
        PFNVKDESTROYINSTANCE vkDestroyInstance = nullptr;
        PFNVKENUMERATEPHYSICALDEVICES vkEnumeratePhysicalDevices = nullptr;
        PFNVKGETPHYSICALDEVICEFEATURES vkGetPhysicalDeviceFeatures = nullptr;
        PFNVKGETPHYSICALDEVICEFORMATPROPERTIES vkGetPhysicalDeviceFormatProperties = nullptr;
        PFNVKGETPHYSICALDEVICEIMAGEFORMATPROPERTIES vkGetPhysicalDeviceImageFormatProperties = nullptr;
        PFNVKGETPHYSICALDEVICEPROPERTIES vkGetPhysicalDeviceProperties = nullptr;
        PFNVKGETPHYSICALDEVICEQUEUEFAMILYPROPERTIES vkGetPhysicalDeviceQueueFamilyProperties = nullptr;
        PFNVKGETPHYSICALDEVICEMEMORYPROPERTIES vkGetPhysicalDeviceMemoryProperties = nullptr;
        PFNVKGETINSTANCEPROCADDR vkGetInstanceProcAddr = nullptr;
        PFNVKCREATEDEVICE vkCreateDevice = nullptr;
        PFNVKENUMERATEDEVICEEXTENSIONPROPERTIES vkEnumerateDeviceExtensionProperties = nullptr;
        PFNVKENUMERATEDEVICELAYERPROPERTIES vkEnumerateDeviceLayerProperties = nullptr;
        PFNVKGETPHYSICALDEVICESPARSEIMAGEFORMATPROPERTIES vkGetPhysicalDeviceSparseImageFormatProperties = nullptr;
        PFNVKDESTROYSURFACEKHR vkDestroySurfaceKHR = nullptr;
        PFNVKGETPHYSICALDEVICESURFACESUPPORTKHR vkGetPhysicalDeviceSurfaceSupportKHR = nullptr;
        PFNVKGETPHYSICALDEVICESURFACECAPABILITIESKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = nullptr;
        PFNVKGETPHYSICALDEVICESURFACEFORMATSKHR vkGetPhysicalDeviceSurfaceFormatsKHR = nullptr;
        PFNVKGETPHYSICALDEVICESURFACEPRESENTMODESKHR vkGetPhysicalDeviceSurfacePresentModesKHR = nullptr;
        PFNVKGETPHYSICALDEVICEDISPLAYPROPERTIESKHR vkGetPhysicalDeviceDisplayPropertiesKHR = nullptr;
        PFNVKGETPHYSICALDEVICEDISPLAYPLANEPROPERTIESKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = nullptr;
        PFNVKGETDISPLAYPLANESUPPORTEDDISPLAYSKHR vkGetDisplayPlaneSupportedDisplaysKHR = nullptr;
        PFNVKGETDISPLAYMODEPROPERTIESKHR vkGetDisplayModePropertiesKHR = nullptr;
        PFNVKCREATEDISPLAYMODEKHR vkCreateDisplayModeKHR = nullptr;
        PFNVKGETDISPLAYPLANECAPABILITIESKHR vkGetDisplayPlaneCapabilitiesKHR = nullptr;
        PFNVKCREATEDISPLAYPLANESURFACEKHR vkCreateDisplayPlaneSurfaceKHR = nullptr;
        PFNVKCREATEDEBUGREPORTCALLBACKEXT vkCreateDebugReportCallbackEXT = nullptr;
        PFNVKDESTROYDEBUGREPORTCALLBACKEXT vkDestroyDebugReportCallbackEXT = nullptr;
        PFNVKDEBUGREPORTMESSAGEEXT vkDebugReportMessageEXT = nullptr;
    };
    std::unordered_map<VkInstance, VkInstanceFunctionStubs> mVkInstanceFunctionStubs;

    struct VkDeviceFunctionStubs {
        PFNVKGETSWAPCHAINGRALLOCUSAGEANDROID vkGetSwapchainGrallocUsageANDROID = nullptr;
        PFNVKACQUIREIMAGEANDROID vkAcquireImageANDROID = nullptr;
        PFNVKQUEUESIGNALRELEASEIMAGEANDROID vkQueueSignalReleaseImageANDROID = nullptr;
        PFNVKGETDEVICEPROCADDR vkGetDeviceProcAddr = nullptr;
        PFNVKDESTROYDEVICE vkDestroyDevice = nullptr;
        PFNVKGETDEVICEQUEUE vkGetDeviceQueue = nullptr;
        PFNVKQUEUESUBMIT vkQueueSubmit = nullptr;
        PFNVKQUEUEWAITIDLE vkQueueWaitIdle = nullptr;
        PFNVKDEVICEWAITIDLE vkDeviceWaitIdle = nullptr;
        PFNVKALLOCATEMEMORY vkAllocateMemory = nullptr;
        PFNVKFREEMEMORY vkFreeMemory = nullptr;
        PFNVKMAPMEMORY vkMapMemory = nullptr;
        PFNVKUNMAPMEMORY vkUnmapMemory = nullptr;
        PFNVKFLUSHMAPPEDMEMORYRANGES vkFlushMappedMemoryRanges = nullptr;
        PFNVKINVALIDATEMAPPEDMEMORYRANGES vkInvalidateMappedMemoryRanges = nullptr;
        PFNVKGETDEVICEMEMORYCOMMITMENT vkGetDeviceMemoryCommitment = nullptr;
        PFNVKBINDBUFFERMEMORY vkBindBufferMemory = nullptr;
        PFNVKBINDIMAGEMEMORY vkBindImageMemory = nullptr;
        PFNVKGETBUFFERMEMORYREQUIREMENTS vkGetBufferMemoryRequirements = nullptr;
        PFNVKGETIMAGEMEMORYREQUIREMENTS vkGetImageMemoryRequirements = nullptr;
        PFNVKGETIMAGESPARSEMEMORYREQUIREMENTS vkGetImageSparseMemoryRequirements = nullptr;
        PFNVKQUEUEBINDSPARSE vkQueueBindSparse = nullptr;
        PFNVKCREATEFENCE vkCreateFence = nullptr;
        PFNVKDESTROYFENCE vkDestroyFence = nullptr;
        PFNVKRESETFENCES vkResetFences = nullptr;
        PFNVKGETFENCESTATUS vkGetFenceStatus = nullptr;
        PFNVKWAITFORFENCES vkWaitForFences = nullptr;
        PFNVKCREATESEMAPHORE vkCreateSemaphore = nullptr;
        PFNVKDESTROYSEMAPHORE vkDestroySemaphore = nullptr;
        PFNVKCREATEEVENT vkCreateEvent = nullptr;
        PFNVKDESTROYEVENT vkDestroyEvent = nullptr;
        PFNVKGETEVENTSTATUS vkGetEventStatus = nullptr;
        PFNVKSETEVENT vkSetEvent = nullptr;
        PFNVKRESETEVENT vkResetEvent = nullptr;
        PFNVKCREATEQUERYPOOL vkCreateQueryPool = nullptr;
        PFNVKDESTROYQUERYPOOL vkDestroyQueryPool = nullptr;
        PFNVKGETQUERYPOOLRESULTS vkGetQueryPoolResults = nullptr;
        PFNVKCREATEBUFFER vkCreateBuffer = nullptr;
        PFNVKDESTROYBUFFER vkDestroyBuffer = nullptr;
        PFNVKCREATEBUFFERVIEW vkCreateBufferView = nullptr;
        PFNVKDESTROYBUFFERVIEW vkDestroyBufferView = nullptr;
        PFNVKCREATEIMAGE vkCreateImage = nullptr;
        PFNVKDESTROYIMAGE vkDestroyImage = nullptr;
        PFNVKGETIMAGESUBRESOURCELAYOUT vkGetImageSubresourceLayout = nullptr;
        PFNVKCREATEIMAGEVIEW vkCreateImageView = nullptr;
        PFNVKDESTROYIMAGEVIEW vkDestroyImageView = nullptr;
        PFNVKCREATESHADERMODULE vkCreateShaderModule = nullptr;
        PFNVKDESTROYSHADERMODULE vkDestroyShaderModule = nullptr;
        PFNVKCREATEPIPELINECACHE vkCreatePipelineCache = nullptr;
        PFNVKDESTROYPIPELINECACHE vkDestroyPipelineCache = nullptr;
        PFNVKGETPIPELINECACHEDATA vkGetPipelineCacheData = nullptr;
        PFNVKMERGEPIPELINECACHES vkMergePipelineCaches = nullptr;
        PFNVKCREATEGRAPHICSPIPELINES vkCreateGraphicsPipelines = nullptr;
        PFNVKCREATECOMPUTEPIPELINES vkCreateComputePipelines = nullptr;
        PFNVKDESTROYPIPELINE vkDestroyPipeline = nullptr;
        PFNVKCREATEPIPELINELAYOUT vkCreatePipelineLayout = nullptr;
        PFNVKDESTROYPIPELINELAYOUT vkDestroyPipelineLayout = nullptr;
        PFNVKCREATESAMPLER vkCreateSampler = nullptr;
        PFNVKDESTROYSAMPLER vkDestroySampler = nullptr;
        PFNVKCREATEDESCRIPTORSETLAYOUT vkCreateDescriptorSetLayout = nullptr;
        PFNVKDESTROYDESCRIPTORSETLAYOUT vkDestroyDescriptorSetLayout = nullptr;
        PFNVKCREATEDESCRIPTORPOOL vkCreateDescriptorPool = nullptr;
        PFNVKDESTROYDESCRIPTORPOOL vkDestroyDescriptorPool = nullptr;
        PFNVKRESETDESCRIPTORPOOL vkResetDescriptorPool = nullptr;
        PFNVKALLOCATEDESCRIPTORSETS vkAllocateDescriptorSets = nullptr;
        PFNVKFREEDESCRIPTORSETS vkFreeDescriptorSets = nullptr;
        PFNVKUPDATEDESCRIPTORSETS vkUpdateDescriptorSets = nullptr;
        PFNVKCREATEFRAMEBUFFER vkCreateFramebuffer = nullptr;
        PFNVKDESTROYFRAMEBUFFER vkDestroyFramebuffer = nullptr;
        PFNVKCREATERENDERPASS vkCreateRenderPass = nullptr;
        PFNVKDESTROYRENDERPASS vkDestroyRenderPass = nullptr;
        PFNVKGETRENDERAREAGRANULARITY vkGetRenderAreaGranularity = nullptr;
        PFNVKCREATECOMMANDPOOL vkCreateCommandPool = nullptr;
        PFNVKDESTROYCOMMANDPOOL vkDestroyCommandPool = nullptr;
        PFNVKRESETCOMMANDPOOL vkResetCommandPool = nullptr;
        PFNVKALLOCATECOMMANDBUFFERS vkAllocateCommandBuffers = nullptr;
        PFNVKFREECOMMANDBUFFERS vkFreeCommandBuffers = nullptr;
        PFNVKBEGINCOMMANDBUFFER vkBeginCommandBuffer = nullptr;
        PFNVKENDCOMMANDBUFFER vkEndCommandBuffer = nullptr;
        PFNVKRESETCOMMANDBUFFER vkResetCommandBuffer = nullptr;
        PFNVKCMDBINDPIPELINE vkCmdBindPipeline = nullptr;
        PFNVKCMDSETVIEWPORT vkCmdSetViewport = nullptr;
        PFNVKCMDSETSCISSOR vkCmdSetScissor = nullptr;
        PFNVKCMDSETLINEWIDTH vkCmdSetLineWidth = nullptr;
        PFNVKCMDSETDEPTHBIAS vkCmdSetDepthBias = nullptr;
        PFNVKCMDSETBLENDCONSTANTS vkCmdSetBlendConstants = nullptr;
        PFNVKCMDSETDEPTHBOUNDS vkCmdSetDepthBounds = nullptr;
        PFNVKCMDSETSTENCILCOMPAREMASK vkCmdSetStencilCompareMask = nullptr;
        PFNVKCMDSETSTENCILWRITEMASK vkCmdSetStencilWriteMask = nullptr;
        PFNVKCMDSETSTENCILREFERENCE vkCmdSetStencilReference = nullptr;
        PFNVKCMDBINDDESCRIPTORSETS vkCmdBindDescriptorSets = nullptr;
        PFNVKCMDBINDINDEXBUFFER vkCmdBindIndexBuffer = nullptr;
        PFNVKCMDBINDVERTEXBUFFERS vkCmdBindVertexBuffers = nullptr;
        PFNVKCMDDRAW vkCmdDraw = nullptr;
        PFNVKCMDDRAWINDEXED vkCmdDrawIndexed = nullptr;
        PFNVKCMDDRAWINDIRECT vkCmdDrawIndirect = nullptr;
        PFNVKCMDDRAWINDEXEDINDIRECT vkCmdDrawIndexedIndirect = nullptr;
        PFNVKCMDDISPATCH vkCmdDispatch = nullptr;
        PFNVKCMDDISPATCHINDIRECT vkCmdDispatchIndirect = nullptr;
        PFNVKCMDCOPYBUFFER vkCmdCopyBuffer = nullptr;
        PFNVKCMDCOPYIMAGE vkCmdCopyImage = nullptr;
        PFNVKCMDBLITIMAGE vkCmdBlitImage = nullptr;
        PFNVKCMDCOPYBUFFERTOIMAGE vkCmdCopyBufferToImage = nullptr;
        PFNVKCMDCOPYIMAGETOBUFFER vkCmdCopyImageToBuffer = nullptr;
        PFNVKCMDUPDATEBUFFER vkCmdUpdateBuffer = nullptr;
        PFNVKCMDFILLBUFFER vkCmdFillBuffer = nullptr;
        PFNVKCMDCLEARCOLORIMAGE vkCmdClearColorImage = nullptr;
        PFNVKCMDCLEARDEPTHSTENCILIMAGE vkCmdClearDepthStencilImage = nullptr;
        PFNVKCMDCLEARATTACHMENTS vkCmdClearAttachments = nullptr;
        PFNVKCMDRESOLVEIMAGE vkCmdResolveImage = nullptr;
        PFNVKCMDSETEVENT vkCmdSetEvent = nullptr;
        PFNVKCMDRESETEVENT vkCmdResetEvent = nullptr;
        PFNVKCMDWAITEVENTS vkCmdWaitEvents = nullptr;
        PFNVKCMDPIPELINEBARRIER vkCmdPipelineBarrier = nullptr;
        PFNVKCMDBEGINQUERY vkCmdBeginQuery = nullptr;
        PFNVKCMDENDQUERY vkCmdEndQuery = nullptr;
        PFNVKCMDRESETQUERYPOOL vkCmdResetQueryPool = nullptr;
        PFNVKCMDWRITETIMESTAMP vkCmdWriteTimestamp = nullptr;
        PFNVKCMDCOPYQUERYPOOLRESULTS vkCmdCopyQueryPoolResults = nullptr;
        PFNVKCMDPUSHCONSTANTS vkCmdPushConstants = nullptr;
        PFNVKCMDBEGINRENDERPASS vkCmdBeginRenderPass = nullptr;
        PFNVKCMDNEXTSUBPASS vkCmdNextSubpass = nullptr;
        PFNVKCMDENDRENDERPASS vkCmdEndRenderPass = nullptr;
        PFNVKCMDEXECUTECOMMANDS vkCmdExecuteCommands = nullptr;
        PFNVKCREATESWAPCHAINKHR vkCreateSwapchainKHR = nullptr;
        PFNVKDESTROYSWAPCHAINKHR vkDestroySwapchainKHR = nullptr;
        PFNVKGETSWAPCHAINIMAGESKHR vkGetSwapchainImagesKHR = nullptr;
        PFNVKACQUIRENEXTIMAGEKHR vkAcquireNextImageKHR = nullptr;
        PFNVKQUEUEPRESENTKHR vkQueuePresentKHR = nullptr;
        PFNVKCREATESHAREDSWAPCHAINSKHR vkCreateSharedSwapchainsKHR = nullptr;
    };
    std::unordered_map<VkDevice, VkDeviceFunctionStubs> mVkDeviceFunctionStubs;

    struct FunctionStubs {
        PFNVKCREATEINSTANCE vkCreateInstance = nullptr;
        PFNVKENUMERATEINSTANCEEXTENSIONPROPERTIES vkEnumerateInstanceExtensionProperties = nullptr;
        PFNVKENUMERATEINSTANCELAYERPROPERTIES vkEnumerateInstanceLayerProperties = nullptr;
    };
    FunctionStubs mFunctionStubs;


    #include "vulkan_gfx_api.inl"

private:
    bool callVkCreateAndroidSurfaceKHR(Stack* stack, bool pushReturn);
    bool callVkGetSwapchainGrallocUsageANDROID(Stack* stack, bool pushReturn);
    bool callVkAcquireImageANDROID(Stack* stack, bool pushReturn);
    bool callVkQueueSignalReleaseImageANDROID(Stack* stack, bool pushReturn);
    bool callVkCreateXlibSurfaceKHR(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceXlibPresentationSupportKHR(Stack* stack, bool pushReturn);
    bool callVkCreateXcbSurfaceKHR(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceXcbPresentationSupportKHR(Stack* stack, bool pushReturn);
    bool callVkCreateWaylandSurfaceKHR(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceWaylandPresentationSupportKHR(Stack* stack, bool pushReturn);
    bool callVkCreateMirSurfaceKHR(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceMirPresentationSupportKHR(Stack* stack, bool pushReturn);
    bool callVkCreateInstance(Stack* stack, bool pushReturn);
    bool callVkDestroyInstance(Stack* stack, bool pushReturn);
    bool callVkEnumeratePhysicalDevices(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceFeatures(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceFormatProperties(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceImageFormatProperties(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceProperties(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceQueueFamilyProperties(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceMemoryProperties(Stack* stack, bool pushReturn);
    bool callVkGetInstanceProcAddr(Stack* stack, bool pushReturn);
    bool callVkGetDeviceProcAddr(Stack* stack, bool pushReturn);
    bool callVkCreateDevice(Stack* stack, bool pushReturn);
    bool callVkDestroyDevice(Stack* stack, bool pushReturn);
    bool callVkEnumerateInstanceExtensionProperties(Stack* stack, bool pushReturn);
    bool callVkEnumerateDeviceExtensionProperties(Stack* stack, bool pushReturn);
    bool callVkEnumerateInstanceLayerProperties(Stack* stack, bool pushReturn);
    bool callVkEnumerateDeviceLayerProperties(Stack* stack, bool pushReturn);
    bool callVkGetDeviceQueue(Stack* stack, bool pushReturn);
    bool callVkQueueSubmit(Stack* stack, bool pushReturn);
    bool callVkQueueWaitIdle(Stack* stack, bool pushReturn);
    bool callVkDeviceWaitIdle(Stack* stack, bool pushReturn);
    bool callVkAllocateMemory(Stack* stack, bool pushReturn);
    bool callVkFreeMemory(Stack* stack, bool pushReturn);
    bool callVkMapMemory(Stack* stack, bool pushReturn);
    bool callVkUnmapMemory(Stack* stack, bool pushReturn);
    bool callVkFlushMappedMemoryRanges(Stack* stack, bool pushReturn);
    bool callVkInvalidateMappedMemoryRanges(Stack* stack, bool pushReturn);
    bool callVkGetDeviceMemoryCommitment(Stack* stack, bool pushReturn);
    bool callVkBindBufferMemory(Stack* stack, bool pushReturn);
    bool callVkBindImageMemory(Stack* stack, bool pushReturn);
    bool callVkGetBufferMemoryRequirements(Stack* stack, bool pushReturn);
    bool callVkGetImageMemoryRequirements(Stack* stack, bool pushReturn);
    bool callVkGetImageSparseMemoryRequirements(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceSparseImageFormatProperties(Stack* stack, bool pushReturn);
    bool callVkQueueBindSparse(Stack* stack, bool pushReturn);
    bool callVkCreateFence(Stack* stack, bool pushReturn);
    bool callVkDestroyFence(Stack* stack, bool pushReturn);
    bool callVkResetFences(Stack* stack, bool pushReturn);
    bool callVkGetFenceStatus(Stack* stack, bool pushReturn);
    bool callVkWaitForFences(Stack* stack, bool pushReturn);
    bool callVkCreateSemaphore(Stack* stack, bool pushReturn);
    bool callVkDestroySemaphore(Stack* stack, bool pushReturn);
    bool callVkCreateEvent(Stack* stack, bool pushReturn);
    bool callVkDestroyEvent(Stack* stack, bool pushReturn);
    bool callVkGetEventStatus(Stack* stack, bool pushReturn);
    bool callVkSetEvent(Stack* stack, bool pushReturn);
    bool callVkResetEvent(Stack* stack, bool pushReturn);
    bool callVkCreateQueryPool(Stack* stack, bool pushReturn);
    bool callVkDestroyQueryPool(Stack* stack, bool pushReturn);
    bool callVkGetQueryPoolResults(Stack* stack, bool pushReturn);
    bool callVkCreateBuffer(Stack* stack, bool pushReturn);
    bool callVkDestroyBuffer(Stack* stack, bool pushReturn);
    bool callVkCreateBufferView(Stack* stack, bool pushReturn);
    bool callVkDestroyBufferView(Stack* stack, bool pushReturn);
    bool callVkCreateImage(Stack* stack, bool pushReturn);
    bool callVkDestroyImage(Stack* stack, bool pushReturn);
    bool callVkGetImageSubresourceLayout(Stack* stack, bool pushReturn);
    bool callVkCreateImageView(Stack* stack, bool pushReturn);
    bool callVkDestroyImageView(Stack* stack, bool pushReturn);
    bool callVkCreateShaderModule(Stack* stack, bool pushReturn);
    bool callVkDestroyShaderModule(Stack* stack, bool pushReturn);
    bool callVkCreatePipelineCache(Stack* stack, bool pushReturn);
    bool callVkDestroyPipelineCache(Stack* stack, bool pushReturn);
    bool callVkGetPipelineCacheData(Stack* stack, bool pushReturn);
    bool callVkMergePipelineCaches(Stack* stack, bool pushReturn);
    bool callVkCreateGraphicsPipelines(Stack* stack, bool pushReturn);
    bool callVkCreateComputePipelines(Stack* stack, bool pushReturn);
    bool callVkDestroyPipeline(Stack* stack, bool pushReturn);
    bool callVkCreatePipelineLayout(Stack* stack, bool pushReturn);
    bool callVkDestroyPipelineLayout(Stack* stack, bool pushReturn);
    bool callVkCreateSampler(Stack* stack, bool pushReturn);
    bool callVkDestroySampler(Stack* stack, bool pushReturn);
    bool callVkCreateDescriptorSetLayout(Stack* stack, bool pushReturn);
    bool callVkDestroyDescriptorSetLayout(Stack* stack, bool pushReturn);
    bool callVkCreateDescriptorPool(Stack* stack, bool pushReturn);
    bool callVkDestroyDescriptorPool(Stack* stack, bool pushReturn);
    bool callVkResetDescriptorPool(Stack* stack, bool pushReturn);
    bool callVkAllocateDescriptorSets(Stack* stack, bool pushReturn);
    bool callVkFreeDescriptorSets(Stack* stack, bool pushReturn);
    bool callVkUpdateDescriptorSets(Stack* stack, bool pushReturn);
    bool callVkCreateFramebuffer(Stack* stack, bool pushReturn);
    bool callVkDestroyFramebuffer(Stack* stack, bool pushReturn);
    bool callVkCreateRenderPass(Stack* stack, bool pushReturn);
    bool callVkDestroyRenderPass(Stack* stack, bool pushReturn);
    bool callVkGetRenderAreaGranularity(Stack* stack, bool pushReturn);
    bool callVkCreateCommandPool(Stack* stack, bool pushReturn);
    bool callVkDestroyCommandPool(Stack* stack, bool pushReturn);
    bool callVkResetCommandPool(Stack* stack, bool pushReturn);
    bool callVkAllocateCommandBuffers(Stack* stack, bool pushReturn);
    bool callVkFreeCommandBuffers(Stack* stack, bool pushReturn);
    bool callVkBeginCommandBuffer(Stack* stack, bool pushReturn);
    bool callVkEndCommandBuffer(Stack* stack, bool pushReturn);
    bool callVkResetCommandBuffer(Stack* stack, bool pushReturn);
    bool callVkCmdBindPipeline(Stack* stack, bool pushReturn);
    bool callVkCmdSetViewport(Stack* stack, bool pushReturn);
    bool callVkCmdSetScissor(Stack* stack, bool pushReturn);
    bool callVkCmdSetLineWidth(Stack* stack, bool pushReturn);
    bool callVkCmdSetDepthBias(Stack* stack, bool pushReturn);
    bool callVkCmdSetBlendConstants(Stack* stack, bool pushReturn);
    bool callVkCmdSetDepthBounds(Stack* stack, bool pushReturn);
    bool callVkCmdSetStencilCompareMask(Stack* stack, bool pushReturn);
    bool callVkCmdSetStencilWriteMask(Stack* stack, bool pushReturn);
    bool callVkCmdSetStencilReference(Stack* stack, bool pushReturn);
    bool callVkCmdBindDescriptorSets(Stack* stack, bool pushReturn);
    bool callVkCmdBindIndexBuffer(Stack* stack, bool pushReturn);
    bool callVkCmdBindVertexBuffers(Stack* stack, bool pushReturn);
    bool callVkCmdDraw(Stack* stack, bool pushReturn);
    bool callVkCmdDrawIndexed(Stack* stack, bool pushReturn);
    bool callVkCmdDrawIndirect(Stack* stack, bool pushReturn);
    bool callVkCmdDrawIndexedIndirect(Stack* stack, bool pushReturn);
    bool callVkCmdDispatch(Stack* stack, bool pushReturn);
    bool callVkCmdDispatchIndirect(Stack* stack, bool pushReturn);
    bool callVkCmdCopyBuffer(Stack* stack, bool pushReturn);
    bool callVkCmdCopyImage(Stack* stack, bool pushReturn);
    bool callVkCmdBlitImage(Stack* stack, bool pushReturn);
    bool callVkCmdCopyBufferToImage(Stack* stack, bool pushReturn);
    bool callVkCmdCopyImageToBuffer(Stack* stack, bool pushReturn);
    bool callVkCmdUpdateBuffer(Stack* stack, bool pushReturn);
    bool callVkCmdFillBuffer(Stack* stack, bool pushReturn);
    bool callVkCmdClearColorImage(Stack* stack, bool pushReturn);
    bool callVkCmdClearDepthStencilImage(Stack* stack, bool pushReturn);
    bool callVkCmdClearAttachments(Stack* stack, bool pushReturn);
    bool callVkCmdResolveImage(Stack* stack, bool pushReturn);
    bool callVkCmdSetEvent(Stack* stack, bool pushReturn);
    bool callVkCmdResetEvent(Stack* stack, bool pushReturn);
    bool callVkCmdWaitEvents(Stack* stack, bool pushReturn);
    bool callVkCmdPipelineBarrier(Stack* stack, bool pushReturn);
    bool callVkCmdBeginQuery(Stack* stack, bool pushReturn);
    bool callVkCmdEndQuery(Stack* stack, bool pushReturn);
    bool callVkCmdResetQueryPool(Stack* stack, bool pushReturn);
    bool callVkCmdWriteTimestamp(Stack* stack, bool pushReturn);
    bool callVkCmdCopyQueryPoolResults(Stack* stack, bool pushReturn);
    bool callVkCmdPushConstants(Stack* stack, bool pushReturn);
    bool callVkCmdBeginRenderPass(Stack* stack, bool pushReturn);
    bool callVkCmdNextSubpass(Stack* stack, bool pushReturn);
    bool callVkCmdEndRenderPass(Stack* stack, bool pushReturn);
    bool callVkCmdExecuteCommands(Stack* stack, bool pushReturn);
    bool callVkDestroySurfaceKHR(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceSurfaceSupportKHR(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceSurfaceCapabilitiesKHR(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceSurfaceFormatsKHR(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceSurfacePresentModesKHR(Stack* stack, bool pushReturn);
    bool callVkCreateSwapchainKHR(Stack* stack, bool pushReturn);
    bool callVkDestroySwapchainKHR(Stack* stack, bool pushReturn);
    bool callVkGetSwapchainImagesKHR(Stack* stack, bool pushReturn);
    bool callVkAcquireNextImageKHR(Stack* stack, bool pushReturn);
    bool callVkQueuePresentKHR(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceDisplayPropertiesKHR(Stack* stack, bool pushReturn);
    bool callVkGetPhysicalDeviceDisplayPlanePropertiesKHR(Stack* stack, bool pushReturn);
    bool callVkGetDisplayPlaneSupportedDisplaysKHR(Stack* stack, bool pushReturn);
    bool callVkGetDisplayModePropertiesKHR(Stack* stack, bool pushReturn);
    bool callVkCreateDisplayModeKHR(Stack* stack, bool pushReturn);
    bool callVkGetDisplayPlaneCapabilitiesKHR(Stack* stack, bool pushReturn);
    bool callVkCreateDisplayPlaneSurfaceKHR(Stack* stack, bool pushReturn);
    bool callVkCreateSharedSwapchainsKHR(Stack* stack, bool pushReturn);
    bool callVkCreateDebugReportCallbackEXT(Stack* stack, bool pushReturn);
    bool callVkDestroyDebugReportCallbackEXT(Stack* stack, bool pushReturn);
    bool callVkDebugReportMessageEXT(Stack* stack, bool pushReturn);
};

}  // namespace gapir

// List of the function identifiers for the builtin API functions.
// This list have to be consistent with the server side because they are part of
// the communication protocol.
// TODO(antiagainst): create a separate file for these builtins.
namespace Builtins {

static const uint16_t ReplayCreateVkInstance = 0x10000 - 188 + 12;
static const uint16_t ReplayCreateVkDevice = 0x10000 - 188 + 13;
static const uint16_t ReplayRegisterVkInstance = 0x10000 - 188 + 14;
static const uint16_t ReplayUnregisterVkInstance = 0x10000 - 188 + 15;
static const uint16_t ReplayRegisterVkDevice = 0x10000 - 188 + 16;
static const uint16_t ReplayUnregisterVkDevice = 0x10000 - 188 + 17;
static const uint16_t ReplayRegisterVkCommandBuffers = 0x10000 - 188 + 18;
static const uint16_t ReplayUnregisterVkCommandBuffers = 0x10000 - 188 + 19;
static const uint16_t ToggleVirtualSwapchainReturnAcquiredImage = 0x10000 - 188 + 20;
static const uint16_t ReplayGetFenceStatus = 0x10000 - 188 + 21;
static const uint16_t ReplayAllocateImageMemory = 0x10000 - 188 + 22;

}  // namespace Builtins

#endif  // GAPIR_VULKAN_GFX_API_H