vk.py

# This file was automatically generated by vkstruct.py
# You may want to edit the generator rather than this file.
import vkbuilder, ctypes

SampleMask = ctypes.c_uint32
Bool32 = ctypes.c_uint32
DeviceSize = ctypes.c_uint64

lib = vkbuilder.load_vulkan()
MAX_PHYSICAL_DEVICE_NAME_SIZE = 256
UUID_SIZE = 16
LUID_SIZE_KHX = 8
MAX_EXTENSION_NAME_SIZE = 256
MAX_DESCRIPTION_SIZE = 256
MAX_MEMORY_TYPES = 32
MAX_MEMORY_HEAPS = 16
LOD_CLAMP_NONE = 1000.0
REMAINING_MIP_LEVELS = -1
REMAINING_ARRAY_LAYERS = -1
WHOLE_SIZE = -1
ATTACHMENT_UNUSED = -1
TRUE = 1
FALSE = 0
QUEUE_FAMILY_IGNORED = -1
QUEUE_FAMILY_EXTERNAL_KHX = (-1-1)
SUBPASS_EXTERNAL = -1
MAX_DEVICE_GROUP_SIZE_KHX = 32

ImageLayout = vkbuilder.Enumeration(u'ImageLayout', {
    u'UNDEFINED'                                      : 0,
    u'GENERAL'                                        : 1,
    u'COLOR_ATTACHMENT_OPTIMAL'                       : 2,
    u'DEPTH_STENCIL_ATTACHMENT_OPTIMAL'               : 3,
    u'DEPTH_STENCIL_READ_ONLY_OPTIMAL'                : 4,
    u'SHADER_READ_ONLY_OPTIMAL'                       : 5,
    u'TRANSFER_SRC_OPTIMAL'                           : 6,
    u'TRANSFER_DST_OPTIMAL'                           : 7,
    u'PREINITIALIZED'                                 : 8,
})
AttachmentLoadOp = vkbuilder.Enumeration(u'AttachmentLoadOp', {
    u'LOAD'                                           : 0,
    u'CLEAR'                                          : 1,
    u'DONT_CARE'                                      : 2,
})
AttachmentStoreOp = vkbuilder.Enumeration(u'AttachmentStoreOp', {
    u'STORE'                                          : 0,
    u'DONT_CARE'                                      : 1,
})
ImageType = vkbuilder.Enumeration(u'ImageType', {
    u'1D'                                             : 0,
    u'2D'                                             : 1,
    u'3D'                                             : 2,
})
ImageTiling = vkbuilder.Enumeration(u'ImageTiling', {
    u'OPTIMAL'                                        : 0,
    u'LINEAR'                                         : 1,
})
ImageViewType = vkbuilder.Enumeration(u'ImageViewType', {
    u'1D'                                             : 0,
    u'2D'                                             : 1,
    u'3D'                                             : 2,
    u'CUBE'                                           : 3,
    u'1D_ARRAY'                                       : 4,
    u'2D_ARRAY'                                       : 5,
    u'CUBE_ARRAY'                                     : 6,
})
CommandBufferLevel = vkbuilder.Enumeration(u'CommandBufferLevel', {
    u'PRIMARY'                                        : 0,
    u'SECONDARY'                                      : 1,
})
ComponentSwizzle = vkbuilder.Enumeration(u'ComponentSwizzle', {
    u'IDENTITY'                                       : 0,
    u'ZERO'                                           : 1,
    u'ONE'                                            : 2,
    u'R'                                              : 3,
    u'G'                                              : 4,
    u'B'                                              : 5,
    u'A'                                              : 6,
})
DescriptorType = vkbuilder.Enumeration(u'DescriptorType', {
    u'SAMPLER'                                        : 0,
    u'COMBINED_IMAGE_SAMPLER'                         : 1,
    u'SAMPLED_IMAGE'                                  : 2,
    u'STORAGE_IMAGE'                                  : 3,
    u'UNIFORM_TEXEL_BUFFER'                           : 4,
    u'STORAGE_TEXEL_BUFFER'                           : 5,
    u'UNIFORM_BUFFER'                                 : 6,
    u'STORAGE_BUFFER'                                 : 7,
    u'UNIFORM_BUFFER_DYNAMIC'                         : 8,
    u'STORAGE_BUFFER_DYNAMIC'                         : 9,
    u'INPUT_ATTACHMENT'                               : 10,
})
QueryType = vkbuilder.Enumeration(u'QueryType', {
    u'OCCLUSION'                                      : 0,
    u'PIPELINE_STATISTICS'                            : 1,
    u'TIMESTAMP'                                      : 2,
})
BorderColor = vkbuilder.Enumeration(u'BorderColor', {
    u'FLOAT_TRANSPARENT_BLACK'                        : 0,
    u'INT_TRANSPARENT_BLACK'                          : 1,
    u'FLOAT_OPAQUE_BLACK'                             : 2,
    u'INT_OPAQUE_BLACK'                               : 3,
    u'FLOAT_OPAQUE_WHITE'                             : 4,
    u'INT_OPAQUE_WHITE'                               : 5,
})
PipelineBindPoint = vkbuilder.Enumeration(u'PipelineBindPoint', {
    u'GRAPHICS'                                       : 0,
    u'COMPUTE'                                        : 1,
})
PipelineCacheHeaderVersion = vkbuilder.Enumeration(u'PipelineCacheHeaderVersion', {
    u'ONE'                                            : 1,
})
PrimitiveTopology = vkbuilder.Enumeration(u'PrimitiveTopology', {
    u'POINT_LIST'                                     : 0,
    u'LINE_LIST'                                      : 1,
    u'LINE_STRIP'                                     : 2,
    u'TRIANGLE_LIST'                                  : 3,
    u'TRIANGLE_STRIP'                                 : 4,
    u'TRIANGLE_FAN'                                   : 5,
    u'LINE_LIST_WITH_ADJACENCY'                       : 6,
    u'LINE_STRIP_WITH_ADJACENCY'                      : 7,
    u'TRIANGLE_LIST_WITH_ADJACENCY'                   : 8,
    u'TRIANGLE_STRIP_WITH_ADJACENCY'                  : 9,
    u'PATCH_LIST'                                     : 10,
})
SharingMode = vkbuilder.Enumeration(u'SharingMode', {
    u'EXCLUSIVE'                                      : 0,
    u'CONCURRENT'                                     : 1,
})
IndexType = vkbuilder.Enumeration(u'IndexType', {
    u'UINT16'                                         : 0,
    u'UINT32'                                         : 1,
})
Filter = vkbuilder.Enumeration(u'Filter', {
    u'NEAREST'                                        : 0,
    u'LINEAR'                                         : 1,
})
SamplerMipmapMode = vkbuilder.Enumeration(u'SamplerMipmapMode', {
    u'NEAREST'                                        : 0,
    u'LINEAR'                                         : 1,
})
SamplerAddressMode = vkbuilder.Enumeration(u'SamplerAddressMode', {
    u'REPEAT'                                         : 0,
    u'MIRRORED_REPEAT'                                : 1,
    u'CLAMP_TO_EDGE'                                  : 2,
    u'CLAMP_TO_BORDER'                                : 3,
})
CompareOp = vkbuilder.Enumeration(u'CompareOp', {
    u'NEVER'                                          : 0,
    u'LESS'                                           : 1,
    u'EQUAL'                                          : 2,
    u'LESS_OR_EQUAL'                                  : 3,
    u'GREATER'                                        : 4,
    u'NOT_EQUAL'                                      : 5,
    u'GREATER_OR_EQUAL'                               : 6,
    u'ALWAYS'                                         : 7,
})
PolygonMode = vkbuilder.Enumeration(u'PolygonMode', {
    u'FILL'                                           : 0,
    u'LINE'                                           : 1,
    u'POINT'                                          : 2,
})
CullModeFlags = vkbuilder.Bitmask(u'CullModeFlags', {
    u'NONE'                                           : 0,
    u'FRONT_BIT'                                      : 1 << 0,
    u'BACK_BIT'                                       : 1 << 1,
    u'FRONT_AND_BACK'                                 : 0x00000003,
})
FrontFace = vkbuilder.Enumeration(u'FrontFace', {
    u'COUNTER_CLOCKWISE'                              : 0,
    u'CLOCKWISE'                                      : 1,
})
BlendFactor = vkbuilder.Enumeration(u'BlendFactor', {
    u'ZERO'                                           : 0,
    u'ONE'                                            : 1,
    u'SRC_COLOR'                                      : 2,
    u'ONE_MINUS_SRC_COLOR'                            : 3,
    u'DST_COLOR'                                      : 4,
    u'ONE_MINUS_DST_COLOR'                            : 5,
    u'SRC_ALPHA'                                      : 6,
    u'ONE_MINUS_SRC_ALPHA'                            : 7,
    u'DST_ALPHA'                                      : 8,
    u'ONE_MINUS_DST_ALPHA'                            : 9,
    u'CONSTANT_COLOR'                                 : 10,
    u'ONE_MINUS_CONSTANT_COLOR'                       : 11,
    u'CONSTANT_ALPHA'                                 : 12,
    u'ONE_MINUS_CONSTANT_ALPHA'                       : 13,
    u'SRC_ALPHA_SATURATE'                             : 14,
    u'SRC1_COLOR'                                     : 15,
    u'ONE_MINUS_SRC1_COLOR'                           : 16,
    u'SRC1_ALPHA'                                     : 17,
    u'ONE_MINUS_SRC1_ALPHA'                           : 18,
})
BlendOp = vkbuilder.Enumeration(u'BlendOp', {
    u'ADD'                                            : 0,
    u'SUBTRACT'                                       : 1,
    u'REVERSE_SUBTRACT'                               : 2,
    u'MIN'                                            : 3,
    u'MAX'                                            : 4,
})
StencilOp = vkbuilder.Enumeration(u'StencilOp', {
    u'KEEP'                                           : 0,
    u'ZERO'                                           : 1,
    u'REPLACE'                                        : 2,
    u'INCREMENT_AND_CLAMP'                            : 3,
    u'DECREMENT_AND_CLAMP'                            : 4,
    u'INVERT'                                         : 5,
    u'INCREMENT_AND_WRAP'                             : 6,
    u'DECREMENT_AND_WRAP'                             : 7,
})
LogicOp = vkbuilder.Enumeration(u'LogicOp', {
    u'CLEAR'                                          : 0,
    u'AND'                                            : 1,
    u'AND_REVERSE'                                    : 2,
    u'COPY'                                           : 3,
    u'AND_INVERTED'                                   : 4,
    u'NO_OP'                                          : 5,
    u'XOR'                                            : 6,
    u'OR'                                             : 7,
    u'NOR'                                            : 8,
    u'EQUIVALENT'                                     : 9,
    u'INVERT'                                         : 10,
    u'OR_REVERSE'                                     : 11,
    u'COPY_INVERTED'                                  : 12,
    u'OR_INVERTED'                                    : 13,
    u'NAND'                                           : 14,
    u'SET'                                            : 15,
})
InternalAllocationType = vkbuilder.Enumeration(u'InternalAllocationType', {
    u'EXECUTABLE'                                     : 0,
})
SystemAllocationScope = vkbuilder.Enumeration(u'SystemAllocationScope', {
    u'COMMAND'                                        : 0,
    u'OBJECT'                                         : 1,
    u'CACHE'                                          : 2,
    u'DEVICE'                                         : 3,
    u'INSTANCE'                                       : 4,
})
PhysicalDeviceType = vkbuilder.Enumeration(u'PhysicalDeviceType', {
    u'OTHER'                                          : 0,
    u'INTEGRATED_GPU'                                 : 1,
    u'DISCRETE_GPU'                                   : 2,
    u'VIRTUAL_GPU'                                    : 3,
    u'CPU'                                            : 4,
})
VertexInputRate = vkbuilder.Enumeration(u'VertexInputRate', {
    u'VERTEX'                                         : 0,
    u'INSTANCE'                                       : 1,
})
Format = vkbuilder.Enumeration(u'Format', {
    u'UNDEFINED'                                      : 0,
    u'R4G4_UNORM_PACK8'                               : 1,
    u'R4G4B4A4_UNORM_PACK16'                          : 2,
    u'B4G4R4A4_UNORM_PACK16'                          : 3,
    u'R5G6B5_UNORM_PACK16'                            : 4,
    u'B5G6R5_UNORM_PACK16'                            : 5,
    u'R5G5B5A1_UNORM_PACK16'                          : 6,
    u'B5G5R5A1_UNORM_PACK16'                          : 7,
    u'A1R5G5B5_UNORM_PACK16'                          : 8,
    u'R8_UNORM'                                       : 9,
    u'R8_SNORM'                                       : 10,
    u'R8_USCALED'                                     : 11,
    u'R8_SSCALED'                                     : 12,
    u'R8_UINT'                                        : 13,
    u'R8_SINT'                                        : 14,
    u'R8_SRGB'                                        : 15,
    u'R8G8_UNORM'                                     : 16,
    u'R8G8_SNORM'                                     : 17,
    u'R8G8_USCALED'                                   : 18,
    u'R8G8_SSCALED'                                   : 19,
    u'R8G8_UINT'                                      : 20,
    u'R8G8_SINT'                                      : 21,
    u'R8G8_SRGB'                                      : 22,
    u'R8G8B8_UNORM'                                   : 23,
    u'R8G8B8_SNORM'                                   : 24,
    u'R8G8B8_USCALED'                                 : 25,
    u'R8G8B8_SSCALED'                                 : 26,
    u'R8G8B8_UINT'                                    : 27,
    u'R8G8B8_SINT'                                    : 28,
    u'R8G8B8_SRGB'                                    : 29,
    u'B8G8R8_UNORM'                                   : 30,
    u'B8G8R8_SNORM'                                   : 31,
    u'B8G8R8_USCALED'                                 : 32,
    u'B8G8R8_SSCALED'                                 : 33,
    u'B8G8R8_UINT'                                    : 34,
    u'B8G8R8_SINT'                                    : 35,
    u'B8G8R8_SRGB'                                    : 36,
    u'R8G8B8A8_UNORM'                                 : 37,
    u'R8G8B8A8_SNORM'                                 : 38,
    u'R8G8B8A8_USCALED'                               : 39,
    u'R8G8B8A8_SSCALED'                               : 40,
    u'R8G8B8A8_UINT'                                  : 41,
    u'R8G8B8A8_SINT'                                  : 42,
    u'R8G8B8A8_SRGB'                                  : 43,
    u'B8G8R8A8_UNORM'                                 : 44,
    u'B8G8R8A8_SNORM'                                 : 45,
    u'B8G8R8A8_USCALED'                               : 46,
    u'B8G8R8A8_SSCALED'                               : 47,
    u'B8G8R8A8_UINT'                                  : 48,
    u'B8G8R8A8_SINT'                                  : 49,
    u'B8G8R8A8_SRGB'                                  : 50,
    u'A8B8G8R8_UNORM_PACK32'                          : 51,
    u'A8B8G8R8_SNORM_PACK32'                          : 52,
    u'A8B8G8R8_USCALED_PACK32'                        : 53,
    u'A8B8G8R8_SSCALED_PACK32'                        : 54,
    u'A8B8G8R8_UINT_PACK32'                           : 55,
    u'A8B8G8R8_SINT_PACK32'                           : 56,
    u'A8B8G8R8_SRGB_PACK32'                           : 57,
    u'A2R10G10B10_UNORM_PACK32'                       : 58,
    u'A2R10G10B10_SNORM_PACK32'                       : 59,
    u'A2R10G10B10_USCALED_PACK32'                     : 60,
    u'A2R10G10B10_SSCALED_PACK32'                     : 61,
    u'A2R10G10B10_UINT_PACK32'                        : 62,
    u'A2R10G10B10_SINT_PACK32'                        : 63,
    u'A2B10G10R10_UNORM_PACK32'                       : 64,
    u'A2B10G10R10_SNORM_PACK32'                       : 65,
    u'A2B10G10R10_USCALED_PACK32'                     : 66,
    u'A2B10G10R10_SSCALED_PACK32'                     : 67,
    u'A2B10G10R10_UINT_PACK32'                        : 68,
    u'A2B10G10R10_SINT_PACK32'                        : 69,
    u'R16_UNORM'                                      : 70,
    u'R16_SNORM'                                      : 71,
    u'R16_USCALED'                                    : 72,
    u'R16_SSCALED'                                    : 73,
    u'R16_UINT'                                       : 74,
    u'R16_SINT'                                       : 75,
    u'R16_SFLOAT'                                     : 76,
    u'R16G16_UNORM'                                   : 77,
    u'R16G16_SNORM'                                   : 78,
    u'R16G16_USCALED'                                 : 79,
    u'R16G16_SSCALED'                                 : 80,
    u'R16G16_UINT'                                    : 81,
    u'R16G16_SINT'                                    : 82,
    u'R16G16_SFLOAT'                                  : 83,
    u'R16G16B16_UNORM'                                : 84,
    u'R16G16B16_SNORM'                                : 85,
    u'R16G16B16_USCALED'                              : 86,
    u'R16G16B16_SSCALED'                              : 87,
    u'R16G16B16_UINT'                                 : 88,
    u'R16G16B16_SINT'                                 : 89,
    u'R16G16B16_SFLOAT'                               : 90,
    u'R16G16B16A16_UNORM'                             : 91,
    u'R16G16B16A16_SNORM'                             : 92,
    u'R16G16B16A16_USCALED'                           : 93,
    u'R16G16B16A16_SSCALED'                           : 94,
    u'R16G16B16A16_UINT'                              : 95,
    u'R16G16B16A16_SINT'                              : 96,
    u'R16G16B16A16_SFLOAT'                            : 97,
    u'R32_UINT'                                       : 98,
    u'R32_SINT'                                       : 99,
    u'R32_SFLOAT'                                     : 100,
    u'R32G32_UINT'                                    : 101,
    u'R32G32_SINT'                                    : 102,
    u'R32G32_SFLOAT'                                  : 103,
    u'R32G32B32_UINT'                                 : 104,
    u'R32G32B32_SINT'                                 : 105,
    u'R32G32B32_SFLOAT'                               : 106,
    u'R32G32B32A32_UINT'                              : 107,
    u'R32G32B32A32_SINT'                              : 108,
    u'R32G32B32A32_SFLOAT'                            : 109,
    u'R64_UINT'                                       : 110,
    u'R64_SINT'                                       : 111,
    u'R64_SFLOAT'                                     : 112,
    u'R64G64_UINT'                                    : 113,
    u'R64G64_SINT'                                    : 114,
    u'R64G64_SFLOAT'                                  : 115,
    u'R64G64B64_UINT'                                 : 116,
    u'R64G64B64_SINT'                                 : 117,
    u'R64G64B64_SFLOAT'                               : 118,
    u'R64G64B64A64_UINT'                              : 119,
    u'R64G64B64A64_SINT'                              : 120,
    u'R64G64B64A64_SFLOAT'                            : 121,
    u'B10G11R11_UFLOAT_PACK32'                        : 122,
    u'E5B9G9R9_UFLOAT_PACK32'                         : 123,
    u'D16_UNORM'                                      : 124,
    u'X8_D24_UNORM_PACK32'                            : 125,
    u'D32_SFLOAT'                                     : 126,
    u'S8_UINT'                                        : 127,
    u'D16_UNORM_S8_UINT'                              : 128,
    u'D24_UNORM_S8_UINT'                              : 129,
    u'D32_SFLOAT_S8_UINT'                             : 130,
    u'BC1_RGB_UNORM_BLOCK'                            : 131,
    u'BC1_RGB_SRGB_BLOCK'                             : 132,
    u'BC1_RGBA_UNORM_BLOCK'                           : 133,
    u'BC1_RGBA_SRGB_BLOCK'                            : 134,
    u'BC2_UNORM_BLOCK'                                : 135,
    u'BC2_SRGB_BLOCK'                                 : 136,
    u'BC3_UNORM_BLOCK'                                : 137,
    u'BC3_SRGB_BLOCK'                                 : 138,
    u'BC4_UNORM_BLOCK'                                : 139,
    u'BC4_SNORM_BLOCK'                                : 140,
    u'BC5_UNORM_BLOCK'                                : 141,
    u'BC5_SNORM_BLOCK'                                : 142,
    u'BC6H_UFLOAT_BLOCK'                              : 143,
    u'BC6H_SFLOAT_BLOCK'                              : 144,
    u'BC7_UNORM_BLOCK'                                : 145,
    u'BC7_SRGB_BLOCK'                                 : 146,
    u'ETC2_R8G8B8_UNORM_BLOCK'                        : 147,
    u'ETC2_R8G8B8_SRGB_BLOCK'                         : 148,
    u'ETC2_R8G8B8A1_UNORM_BLOCK'                      : 149,
    u'ETC2_R8G8B8A1_SRGB_BLOCK'                       : 150,
    u'ETC2_R8G8B8A8_UNORM_BLOCK'                      : 151,
    u'ETC2_R8G8B8A8_SRGB_BLOCK'                       : 152,
    u'EAC_R11_UNORM_BLOCK'                            : 153,
    u'EAC_R11_SNORM_BLOCK'                            : 154,
    u'EAC_R11G11_UNORM_BLOCK'                         : 155,
    u'EAC_R11G11_SNORM_BLOCK'                         : 156,
    u'ASTC_4x4_UNORM_BLOCK'                           : 157,
    u'ASTC_4x4_SRGB_BLOCK'                            : 158,
    u'ASTC_5x4_UNORM_BLOCK'                           : 159,
    u'ASTC_5x4_SRGB_BLOCK'                            : 160,
    u'ASTC_5x5_UNORM_BLOCK'                           : 161,
    u'ASTC_5x5_SRGB_BLOCK'                            : 162,
    u'ASTC_6x5_UNORM_BLOCK'                           : 163,
    u'ASTC_6x5_SRGB_BLOCK'                            : 164,
    u'ASTC_6x6_UNORM_BLOCK'                           : 165,
    u'ASTC_6x6_SRGB_BLOCK'                            : 166,
    u'ASTC_8x5_UNORM_BLOCK'                           : 167,
    u'ASTC_8x5_SRGB_BLOCK'                            : 168,
    u'ASTC_8x6_UNORM_BLOCK'                           : 169,
    u'ASTC_8x6_SRGB_BLOCK'                            : 170,
    u'ASTC_8x8_UNORM_BLOCK'                           : 171,
    u'ASTC_8x8_SRGB_BLOCK'                            : 172,
    u'ASTC_10x5_UNORM_BLOCK'                          : 173,
    u'ASTC_10x5_SRGB_BLOCK'                           : 174,
    u'ASTC_10x6_UNORM_BLOCK'                          : 175,
    u'ASTC_10x6_SRGB_BLOCK'                           : 176,
    u'ASTC_10x8_UNORM_BLOCK'                          : 177,
    u'ASTC_10x8_SRGB_BLOCK'                           : 178,
    u'ASTC_10x10_UNORM_BLOCK'                         : 179,
    u'ASTC_10x10_SRGB_BLOCK'                          : 180,
    u'ASTC_12x10_UNORM_BLOCK'                         : 181,
    u'ASTC_12x10_SRGB_BLOCK'                          : 182,
    u'ASTC_12x12_UNORM_BLOCK'                         : 183,
    u'ASTC_12x12_SRGB_BLOCK'                          : 184,
})
StructureType = vkbuilder.Enumeration(u'StructureType', {
    u'APPLICATION_INFO'                               : 0,
    u'INSTANCE_CREATE_INFO'                           : 1,
    u'DEVICE_QUEUE_CREATE_INFO'                       : 2,
    u'DEVICE_CREATE_INFO'                             : 3,
    u'SUBMIT_INFO'                                    : 4,
    u'MEMORY_ALLOCATE_INFO'                           : 5,
    u'MAPPED_MEMORY_RANGE'                            : 6,
    u'BIND_SPARSE_INFO'                               : 7,
    u'FENCE_CREATE_INFO'                              : 8,
    u'SEMAPHORE_CREATE_INFO'                          : 9,
    u'EVENT_CREATE_INFO'                              : 10,
    u'QUERY_POOL_CREATE_INFO'                         : 11,
    u'BUFFER_CREATE_INFO'                             : 12,
    u'BUFFER_VIEW_CREATE_INFO'                        : 13,
    u'IMAGE_CREATE_INFO'                              : 14,
    u'IMAGE_VIEW_CREATE_INFO'                         : 15,
    u'SHADER_MODULE_CREATE_INFO'                      : 16,
    u'PIPELINE_CACHE_CREATE_INFO'                     : 17,
    u'PIPELINE_SHADER_STAGE_CREATE_INFO'              : 18,
    u'PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO'        : 19,
    u'PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO'      : 20,
    u'PIPELINE_TESSELLATION_STATE_CREATE_INFO'        : 21,
    u'PIPELINE_VIEWPORT_STATE_CREATE_INFO'            : 22,
    u'PIPELINE_RASTERIZATION_STATE_CREATE_INFO'       : 23,
    u'PIPELINE_MULTISAMPLE_STATE_CREATE_INFO'         : 24,
    u'PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO'       : 25,
    u'PIPELINE_COLOR_BLEND_STATE_CREATE_INFO'         : 26,
    u'PIPELINE_DYNAMIC_STATE_CREATE_INFO'             : 27,
    u'GRAPHICS_PIPELINE_CREATE_INFO'                  : 28,
    u'COMPUTE_PIPELINE_CREATE_INFO'                   : 29,
    u'PIPELINE_LAYOUT_CREATE_INFO'                    : 30,
    u'SAMPLER_CREATE_INFO'                            : 31,
    u'DESCRIPTOR_SET_LAYOUT_CREATE_INFO'              : 32,
    u'DESCRIPTOR_POOL_CREATE_INFO'                    : 33,
    u'DESCRIPTOR_SET_ALLOCATE_INFO'                   : 34,
    u'WRITE_DESCRIPTOR_SET'                           : 35,
    u'COPY_DESCRIPTOR_SET'                            : 36,
    u'FRAMEBUFFER_CREATE_INFO'                        : 37,
    u'RENDER_PASS_CREATE_INFO'                        : 38,
    u'COMMAND_POOL_CREATE_INFO'                       : 39,
    u'COMMAND_BUFFER_ALLOCATE_INFO'                   : 40,
    u'COMMAND_BUFFER_INHERITANCE_INFO'                : 41,
    u'COMMAND_BUFFER_BEGIN_INFO'                      : 42,
    u'RENDER_PASS_BEGIN_INFO'                         : 43,
    u'BUFFER_MEMORY_BARRIER'                          : 44,
    u'IMAGE_MEMORY_BARRIER'                           : 45,
    u'MEMORY_BARRIER'                                 : 46,
    u'LOADER_INSTANCE_CREATE_INFO'                    : 47,
    u'LOADER_DEVICE_CREATE_INFO'                      : 48,
})
SubpassContents = vkbuilder.Enumeration(u'SubpassContents', {
    u'INLINE'                                         : 0,
    u'SECONDARY_COMMAND_BUFFERS'                      : 1,
})
Result = vkbuilder.Enumeration(u'Result', {
    u'SUCCESS'                                        : 0,
    u'NOT_READY'                                      : 1,
    u'TIMEOUT'                                        : 2,
    u'EVENT_SET'                                      : 3,
    u'EVENT_RESET'                                    : 4,
    u'INCOMPLETE'                                     : 5,
    u'ERROR_OUT_OF_HOST_MEMORY'                       : -1,
    u'ERROR_OUT_OF_DEVICE_MEMORY'                     : -2,
    u'ERROR_INITIALIZATION_FAILED'                    : -3,
    u'ERROR_DEVICE_LOST'                              : -4,
    u'ERROR_MEMORY_MAP_FAILED'                        : -5,
    u'ERROR_LAYER_NOT_PRESENT'                        : -6,
    u'ERROR_EXTENSION_NOT_PRESENT'                    : -7,
    u'ERROR_FEATURE_NOT_PRESENT'                      : -8,
    u'ERROR_INCOMPATIBLE_DRIVER'                      : -9,
    u'ERROR_TOO_MANY_OBJECTS'                         : -10,
    u'ERROR_FORMAT_NOT_SUPPORTED'                     : -11,
    u'ERROR_FRAGMENTED_POOL'                          : -12,
})
DynamicState = vkbuilder.Enumeration(u'DynamicState', {
    u'VIEWPORT'                                       : 0,
    u'SCISSOR'                                        : 1,
    u'LINE_WIDTH'                                     : 2,
    u'DEPTH_BIAS'                                     : 3,
    u'BLEND_CONSTANTS'                                : 4,
    u'DEPTH_BOUNDS'                                   : 5,
    u'STENCIL_COMPARE_MASK'                           : 6,
    u'STENCIL_WRITE_MASK'                             : 7,
    u'STENCIL_REFERENCE'                              : 8,
})
DescriptorUpdateTemplateTypeKHR = vkbuilder.Enumeration(u'DescriptorUpdateTemplateTypeKHR', {
    u'DESCRIPTOR_SET_KHR'                             : 0,
    u'PUSH_DESCRIPTORS_KHR'                           : 1,
})
QueueFlags = vkbuilder.Bitmask(u'QueueFlags', {
    u'GRAPHICS_BIT'                                   : 1 << 0,
    u'COMPUTE_BIT'                                    : 1 << 1,
    u'TRANSFER_BIT'                                   : 1 << 2,
    u'SPARSE_BINDING_BIT'                             : 1 << 3,
})
MemoryPropertyFlags = vkbuilder.Bitmask(u'MemoryPropertyFlags', {
    u'DEVICE_LOCAL_BIT'                               : 1 << 0,
    u'HOST_VISIBLE_BIT'                               : 1 << 1,
    u'HOST_COHERENT_BIT'                              : 1 << 2,
    u'HOST_CACHED_BIT'                                : 1 << 3,
    u'LAZILY_ALLOCATED_BIT'                           : 1 << 4,
})
MemoryHeapFlags = vkbuilder.Bitmask(u'MemoryHeapFlags', {
    u'DEVICE_LOCAL_BIT'                               : 1 << 0,
})
AccessFlags = vkbuilder.Bitmask(u'AccessFlags', {
    u'INDIRECT_COMMAND_READ_BIT'                      : 1 << 0,
    u'INDEX_READ_BIT'                                 : 1 << 1,
    u'VERTEX_ATTRIBUTE_READ_BIT'                      : 1 << 2,
    u'UNIFORM_READ_BIT'                               : 1 << 3,
    u'INPUT_ATTACHMENT_READ_BIT'                      : 1 << 4,
    u'SHADER_READ_BIT'                                : 1 << 5,
    u'SHADER_WRITE_BIT'                               : 1 << 6,
    u'COLOR_ATTACHMENT_READ_BIT'                      : 1 << 7,
    u'COLOR_ATTACHMENT_WRITE_BIT'                     : 1 << 8,
    u'DEPTH_STENCIL_ATTACHMENT_READ_BIT'              : 1 << 9,
    u'DEPTH_STENCIL_ATTACHMENT_WRITE_BIT'             : 1 << 10,
    u'TRANSFER_READ_BIT'                              : 1 << 11,
    u'TRANSFER_WRITE_BIT'                             : 1 << 12,
    u'HOST_READ_BIT'                                  : 1 << 13,
    u'HOST_WRITE_BIT'                                 : 1 << 14,
    u'MEMORY_READ_BIT'                                : 1 << 15,
    u'MEMORY_WRITE_BIT'                               : 1 << 16,
})
BufferUsageFlags = vkbuilder.Bitmask(u'BufferUsageFlags', {
    u'TRANSFER_SRC_BIT'                               : 1 << 0,
    u'TRANSFER_DST_BIT'                               : 1 << 1,
    u'UNIFORM_TEXEL_BUFFER_BIT'                       : 1 << 2,
    u'STORAGE_TEXEL_BUFFER_BIT'                       : 1 << 3,
    u'UNIFORM_BUFFER_BIT'                             : 1 << 4,
    u'STORAGE_BUFFER_BIT'                             : 1 << 5,
    u'INDEX_BUFFER_BIT'                               : 1 << 6,
    u'VERTEX_BUFFER_BIT'                              : 1 << 7,
    u'INDIRECT_BUFFER_BIT'                            : 1 << 8,
})
BufferCreateFlags = vkbuilder.Bitmask(u'BufferCreateFlags', {
    u'SPARSE_BINDING_BIT'                             : 1 << 0,
    u'SPARSE_RESIDENCY_BIT'                           : 1 << 1,
    u'SPARSE_ALIASED_BIT'                             : 1 << 2,
})
ShaderStageFlags = vkbuilder.Bitmask(u'ShaderStageFlags', {
    u'VERTEX_BIT'                                     : 1 << 0,
    u'TESSELLATION_CONTROL_BIT'                       : 1 << 1,
    u'TESSELLATION_EVALUATION_BIT'                    : 1 << 2,
    u'GEOMETRY_BIT'                                   : 1 << 3,
    u'FRAGMENT_BIT'                                   : 1 << 4,
    u'COMPUTE_BIT'                                    : 1 << 5,
    u'ALL_GRAPHICS'                                   : 0x0000001F,
    u'ALL'                                            : 0x7FFFFFFF,
})
ImageUsageFlags = vkbuilder.Bitmask(u'ImageUsageFlags', {
    u'TRANSFER_SRC_BIT'                               : 1 << 0,
    u'TRANSFER_DST_BIT'                               : 1 << 1,
    u'SAMPLED_BIT'                                    : 1 << 2,
    u'STORAGE_BIT'                                    : 1 << 3,
    u'COLOR_ATTACHMENT_BIT'                           : 1 << 4,
    u'DEPTH_STENCIL_ATTACHMENT_BIT'                   : 1 << 5,
    u'TRANSIENT_ATTACHMENT_BIT'                       : 1 << 6,
    u'INPUT_ATTACHMENT_BIT'                           : 1 << 7,
})
ImageCreateFlags = vkbuilder.Bitmask(u'ImageCreateFlags', {
    u'SPARSE_BINDING_BIT'                             : 1 << 0,
    u'SPARSE_RESIDENCY_BIT'                           : 1 << 1,
    u'SPARSE_ALIASED_BIT'                             : 1 << 2,
    u'MUTABLE_FORMAT_BIT'                             : 1 << 3,
    u'CUBE_COMPATIBLE_BIT'                            : 1 << 4,
})
PipelineCreateFlags = vkbuilder.Bitmask(u'PipelineCreateFlags', {
    u'DISABLE_OPTIMIZATION_BIT'                       : 1 << 0,
    u'ALLOW_DERIVATIVES_BIT'                          : 1 << 1,
    u'DERIVATIVE_BIT'                                 : 1 << 2,
})
ColorComponentFlags = vkbuilder.Bitmask(u'ColorComponentFlags', {
    u'R_BIT'                                          : 1 << 0,
    u'G_BIT'                                          : 1 << 1,
    u'B_BIT'                                          : 1 << 2,
    u'A_BIT'                                          : 1 << 3,
})
FenceCreateFlags = vkbuilder.Bitmask(u'FenceCreateFlags', {
    u'SIGNALED_BIT'                                   : 1 << 0,
})
FormatFeatureFlags = vkbuilder.Bitmask(u'FormatFeatureFlags', {
    u'SAMPLED_IMAGE_BIT'                              : 1 << 0,
    u'STORAGE_IMAGE_BIT'                              : 1 << 1,
    u'STORAGE_IMAGE_ATOMIC_BIT'                       : 1 << 2,
    u'UNIFORM_TEXEL_BUFFER_BIT'                       : 1 << 3,
    u'STORAGE_TEXEL_BUFFER_BIT'                       : 1 << 4,
    u'STORAGE_TEXEL_BUFFER_ATOMIC_BIT'                : 1 << 5,
    u'VERTEX_BUFFER_BIT'                              : 1 << 6,
    u'COLOR_ATTACHMENT_BIT'                           : 1 << 7,
    u'COLOR_ATTACHMENT_BLEND_BIT'                     : 1 << 8,
    u'DEPTH_STENCIL_ATTACHMENT_BIT'                   : 1 << 9,
    u'BLIT_SRC_BIT'                                   : 1 << 10,
    u'BLIT_DST_BIT'                                   : 1 << 11,
    u'SAMPLED_IMAGE_FILTER_LINEAR_BIT'                : 1 << 12,
})
QueryControlFlags = vkbuilder.Bitmask(u'QueryControlFlags', {
    u'PRECISE_BIT'                                    : 1 << 0,
})
QueryResultFlags = vkbuilder.Bitmask(u'QueryResultFlags', {
    u'64_BIT'                                         : 1 << 0,
    u'WAIT_BIT'                                       : 1 << 1,
    u'WITH_AVAILABILITY_BIT'                          : 1 << 2,
    u'PARTIAL_BIT'                                    : 1 << 3,
})
CommandBufferUsageFlags = vkbuilder.Bitmask(u'CommandBufferUsageFlags', {
    u'ONE_TIME_SUBMIT_BIT'                            : 1 << 0,
    u'RENDER_PASS_CONTINUE_BIT'                       : 1 << 1,
    u'SIMULTANEOUS_USE_BIT'                           : 1 << 2,
})
QueryPipelineStatisticFlags = vkbuilder.Bitmask(u'QueryPipelineStatisticFlags', {
    u'INPUT_ASSEMBLY_VERTICES_BIT'                    : 1 << 0,
    u'INPUT_ASSEMBLY_PRIMITIVES_BIT'                  : 1 << 1,
    u'VERTEX_SHADER_INVOCATIONS_BIT'                  : 1 << 2,
    u'GEOMETRY_SHADER_INVOCATIONS_BIT'                : 1 << 3,
    u'GEOMETRY_SHADER_PRIMITIVES_BIT'                 : 1 << 4,
    u'CLIPPING_INVOCATIONS_BIT'                       : 1 << 5,
    u'CLIPPING_PRIMITIVES_BIT'                        : 1 << 6,
    u'FRAGMENT_SHADER_INVOCATIONS_BIT'                : 1 << 7,
    u'TESSELLATION_CONTROL_SHADER_PATCHES_BIT'        : 1 << 8,
    u'TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT' : 1 << 9,
    u'COMPUTE_SHADER_INVOCATIONS_BIT'                 : 1 << 10,
})
ImageAspectFlags = vkbuilder.Bitmask(u'ImageAspectFlags', {
    u'COLOR_BIT'                                      : 1 << 0,
    u'DEPTH_BIT'                                      : 1 << 1,
    u'STENCIL_BIT'                                    : 1 << 2,
    u'METADATA_BIT'                                   : 1 << 3,
})
SparseImageFormatFlags = vkbuilder.Bitmask(u'SparseImageFormatFlags', {
    u'SINGLE_MIPTAIL_BIT'                             : 1 << 0,
    u'ALIGNED_MIP_SIZE_BIT'                           : 1 << 1,
    u'NONSTANDARD_BLOCK_SIZE_BIT'                     : 1 << 2,
})
SparseMemoryBindFlags = vkbuilder.Bitmask(u'SparseMemoryBindFlags', {
    u'METADATA_BIT'                                   : 1 << 0,
})
PipelineStageFlags = vkbuilder.Bitmask(u'PipelineStageFlags', {
    u'TOP_OF_PIPE_BIT'                                : 1 << 0,
    u'DRAW_INDIRECT_BIT'                              : 1 << 1,
    u'VERTEX_INPUT_BIT'                               : 1 << 2,
    u'VERTEX_SHADER_BIT'                              : 1 << 3,
    u'TESSELLATION_CONTROL_SHADER_BIT'                : 1 << 4,
    u'TESSELLATION_EVALUATION_SHADER_BIT'             : 1 << 5,
    u'GEOMETRY_SHADER_BIT'                            : 1 << 6,
    u'FRAGMENT_SHADER_BIT'                            : 1 << 7,
    u'EARLY_FRAGMENT_TESTS_BIT'                       : 1 << 8,
    u'LATE_FRAGMENT_TESTS_BIT'                        : 1 << 9,
    u'COLOR_ATTACHMENT_OUTPUT_BIT'                    : 1 << 10,
    u'COMPUTE_SHADER_BIT'                             : 1 << 11,
    u'TRANSFER_BIT'                                   : 1 << 12,
    u'BOTTOM_OF_PIPE_BIT'                             : 1 << 13,
    u'HOST_BIT'                                       : 1 << 14,
    u'ALL_GRAPHICS_BIT'                               : 1 << 15,
    u'ALL_COMMANDS_BIT'                               : 1 << 16,
})
CommandPoolCreateFlags = vkbuilder.Bitmask(u'CommandPoolCreateFlags', {
    u'TRANSIENT_BIT'                                  : 1 << 0,
    u'RESET_COMMAND_BUFFER_BIT'                       : 1 << 1,
})
CommandPoolResetFlags = vkbuilder.Bitmask(u'CommandPoolResetFlags', {
    u'RELEASE_RESOURCES_BIT'                          : 1 << 0,
})
CommandBufferResetFlags = vkbuilder.Bitmask(u'CommandBufferResetFlags', {
    u'RELEASE_RESOURCES_BIT'                          : 1 << 0,
})
SampleCountFlags = vkbuilder.Bitmask(u'SampleCountFlags', {
    u'1_BIT'                                          : 1 << 0,
    u'2_BIT'                                          : 1 << 1,
    u'4_BIT'                                          : 1 << 2,
    u'8_BIT'                                          : 1 << 3,
    u'16_BIT'                                         : 1 << 4,
    u'32_BIT'                                         : 1 << 5,
    u'64_BIT'                                         : 1 << 6,
})
AttachmentDescriptionFlags = vkbuilder.Bitmask(u'AttachmentDescriptionFlags', {
    u'MAY_ALIAS_BIT'                                  : 1 << 0,
})
StencilFaceFlags = vkbuilder.Bitmask(u'StencilFaceFlags', {
    u'FRONT_BIT'                                      : 1 << 0,
    u'BACK_BIT'                                       : 1 << 1,
    u'FRONT_AND_BACK'                                 : 0x00000003,
})
DescriptorPoolCreateFlags = vkbuilder.Bitmask(u'DescriptorPoolCreateFlags', {
    u'FREE_DESCRIPTOR_SET_BIT'                        : 1 << 0,
})
DependencyFlags = vkbuilder.Bitmask(u'DependencyFlags', {
    u'BY_REGION_BIT'                                  : 1 << 0,
})
PresentModeKHR = vkbuilder.Enumeration(u'PresentModeKHR', {
    u'IMMEDIATE_KHR'                                  : 0,
    u'MAILBOX_KHR'                                    : 1,
    u'FIFO_KHR'                                       : 2,
    u'FIFO_RELAXED_KHR'                               : 3,
})
ColorSpaceKHR = vkbuilder.Enumeration(u'ColorSpaceKHR', {
    u'SRGB_NONLINEAR_KHR'                             : 0,
})
DisplayPlaneAlphaFlagsKHR = vkbuilder.Bitmask(u'DisplayPlaneAlphaFlagsKHR', {
    u'OPAQUE_BIT_KHR'                                 : 1 << 0,
    u'GLOBAL_BIT_KHR'                                 : 1 << 1,
    u'PER_PIXEL_BIT_KHR'                              : 1 << 2,
    u'PER_PIXEL_PREMULTIPLIED_BIT_KHR'                : 1 << 3,
})
CompositeAlphaFlagsKHR = vkbuilder.Bitmask(u'CompositeAlphaFlagsKHR', {
    u'OPAQUE_BIT_KHR'                                 : 1 << 0,
    u'PRE_MULTIPLIED_BIT_KHR'                         : 1 << 1,
    u'POST_MULTIPLIED_BIT_KHR'                        : 1 << 2,
    u'INHERIT_BIT_KHR'                                : 1 << 3,
})
SurfaceTransformFlagsKHR = vkbuilder.Bitmask(u'SurfaceTransformFlagsKHR', {
    u'IDENTITY_BIT_KHR'                               : 1 << 0,
    u'ROTATE_90_BIT_KHR'                              : 1 << 1,
    u'ROTATE_180_BIT_KHR'                             : 1 << 2,
    u'ROTATE_270_BIT_KHR'                             : 1 << 3,
    u'HORIZONTAL_MIRROR_BIT_KHR'                      : 1 << 4,
    u'HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR'            : 1 << 5,
    u'HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR'           : 1 << 6,
    u'HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR'           : 1 << 7,
    u'INHERIT_BIT_KHR'                                : 1 << 8,
})
DebugReportFlagsEXT = vkbuilder.Bitmask(u'DebugReportFlagsEXT', {
    u'INFORMATION_BIT_EXT'                            : 1 << 0,
    u'WARNING_BIT_EXT'                                : 1 << 1,
    u'PERFORMANCE_WARNING_BIT_EXT'                    : 1 << 2,
    u'ERROR_BIT_EXT'                                  : 1 << 3,
    u'DEBUG_BIT_EXT'                                  : 1 << 4,
})
DebugReportObjectTypeEXT = vkbuilder.Enumeration(u'DebugReportObjectTypeEXT', {
    u'UNKNOWN_EXT'                                    : 0,
    u'INSTANCE_EXT'                                   : 1,
    u'PHYSICAL_DEVICE_EXT'                            : 2,
    u'DEVICE_EXT'                                     : 3,
    u'QUEUE_EXT'                                      : 4,
    u'SEMAPHORE_EXT'                                  : 5,
    u'COMMAND_BUFFER_EXT'                             : 6,
    u'FENCE_EXT'                                      : 7,
    u'DEVICE_MEMORY_EXT'                              : 8,
    u'BUFFER_EXT'                                     : 9,
    u'IMAGE_EXT'                                      : 10,
    u'EVENT_EXT'                                      : 11,
    u'QUERY_POOL_EXT'                                 : 12,
    u'BUFFER_VIEW_EXT'                                : 13,
    u'IMAGE_VIEW_EXT'                                 : 14,
    u'SHADER_MODULE_EXT'                              : 15,
    u'PIPELINE_CACHE_EXT'                             : 16,
    u'PIPELINE_LAYOUT_EXT'                            : 17,
    u'RENDER_PASS_EXT'                                : 18,
    u'PIPELINE_EXT'                                   : 19,
    u'DESCRIPTOR_SET_LAYOUT_EXT'                      : 20,
    u'SAMPLER_EXT'                                    : 21,
    u'DESCRIPTOR_POOL_EXT'                            : 22,
    u'DESCRIPTOR_SET_EXT'                             : 23,
    u'FRAMEBUFFER_EXT'                                : 24,
    u'COMMAND_POOL_EXT'                               : 25,
    u'SURFACE_KHR_EXT'                                : 26,
    u'SWAPCHAIN_KHR_EXT'                              : 27,
    u'DEBUG_REPORT_EXT'                               : 28,
    u'DISPLAY_KHR_EXT'                                : 29,
    u'DISPLAY_MODE_KHR_EXT'                           : 30,
    u'OBJECT_TABLE_NVX_EXT'                           : 31,
    u'INDIRECT_COMMANDS_LAYOUT_NVX_EXT'               : 32,
})
DebugReportErrorEXT = vkbuilder.Enumeration(u'DebugReportErrorEXT', {
    u'NONE_EXT'                                       : 0,
    u'CALLBACK_REF_EXT'                               : 1,
})
RasterizationOrderAMD = vkbuilder.Enumeration(u'RasterizationOrderAMD', {
    u'STRICT_AMD'                                     : 0,
    u'RELAXED_AMD'                                    : 1,
})
ExternalMemoryHandleTypeFlagsNV = vkbuilder.Bitmask(u'ExternalMemoryHandleTypeFlagsNV', {
    u'OPAQUE_WIN32_BIT_NV'                            : 1 << 0,
    u'OPAQUE_WIN32_KMT_BIT_NV'                        : 1 << 1,
    u'D3D11_IMAGE_BIT_NV'                             : 1 << 2,
    u'D3D11_IMAGE_KMT_BIT_NV'                         : 1 << 3,
})
ExternalMemoryFeatureFlagsNV = vkbuilder.Bitmask(u'ExternalMemoryFeatureFlagsNV', {
    u'DEDICATED_ONLY_BIT_NV'                          : 1 << 0,
    u'EXPORTABLE_BIT_NV'                              : 1 << 1,
    u'IMPORTABLE_BIT_NV'                              : 1 << 2,
})
ValidationCheckEXT = vkbuilder.Enumeration(u'ValidationCheckEXT', {
    u'ALL_EXT'                                        : 0,
})
IndirectCommandsLayoutUsageFlagsNVX = vkbuilder.Bitmask(u'IndirectCommandsLayoutUsageFlagsNVX', {
    u'UNORDERED_SEQUENCES_BIT_NVX'                    : 1 << 0,
    u'SPARSE_SEQUENCES_BIT_NVX'                       : 1 << 1,
    u'EMPTY_EXECUTIONS_BIT_NVX'                       : 1 << 2,
    u'INDEXED_SEQUENCES_BIT_NVX'                      : 1 << 3,
})
ObjectEntryUsageFlagsNVX = vkbuilder.Bitmask(u'ObjectEntryUsageFlagsNVX', {
    u'GRAPHICS_BIT_NVX'                               : 1 << 0,
    u'COMPUTE_BIT_NVX'                                : 1 << 1,
})
IndirectCommandsTokenTypeNVX = vkbuilder.Enumeration(u'IndirectCommandsTokenTypeNVX', {
    u'PIPELINE_NVX'                                   : 0,
    u'DESCRIPTOR_SET_NVX'                             : 1,
    u'INDEX_BUFFER_NVX'                               : 2,
    u'VERTEX_BUFFER_NVX'                              : 3,
    u'PUSH_CONSTANT_NVX'                              : 4,
    u'DRAW_INDEXED_NVX'                               : 5,
    u'DRAW_NVX'                                       : 6,
    u'DISPATCH_NVX'                                   : 7,
})
ObjectEntryTypeNVX = vkbuilder.Enumeration(u'ObjectEntryTypeNVX', {
    u'DESCRIPTOR_SET_NVX'                             : 0,
    u'PIPELINE_NVX'                                   : 1,
    u'INDEX_BUFFER_NVX'                               : 2,
    u'VERTEX_BUFFER_NVX'                              : 3,
    u'PUSH_CONSTANT_NVX'                              : 4,
})
DescriptorSetLayoutCreateFlags = vkbuilder.Bitmask(u'DescriptorSetLayoutCreateFlags', {
})
ExternalMemoryHandleTypeFlagsKHX = vkbuilder.Bitmask(u'ExternalMemoryHandleTypeFlagsKHX', {
    u'OPAQUE_FD_BIT_KHX'                              : 1 << 0,
    u'OPAQUE_WIN32_BIT_KHX'                           : 1 << 1,
    u'OPAQUE_WIN32_KMT_BIT_KHX'                       : 1 << 2,
    u'D3D11_TEXTURE_BIT_KHX'                          : 1 << 3,
    u'D3D11_TEXTURE_KMT_BIT_KHX'                      : 1 << 4,
    u'D3D12_HEAP_BIT_KHX'                             : 1 << 5,
    u'D3D12_RESOURCE_BIT_KHX'                         : 1 << 6,
})
ExternalMemoryFeatureFlagsKHX = vkbuilder.Bitmask(u'ExternalMemoryFeatureFlagsKHX', {
    u'DEDICATED_ONLY_BIT_KHX'                         : 1 << 0,
    u'EXPORTABLE_BIT_KHX'                             : 1 << 1,
    u'IMPORTABLE_BIT_KHX'                             : 1 << 2,
})
ExternalSemaphoreHandleTypeFlagsKHX = vkbuilder.Bitmask(u'ExternalSemaphoreHandleTypeFlagsKHX', {
    u'OPAQUE_FD_BIT_KHX'                              : 1 << 0,
    u'OPAQUE_WIN32_BIT_KHX'                           : 1 << 1,
    u'OPAQUE_WIN32_KMT_BIT_KHX'                       : 1 << 2,
    u'D3D12_FENCE_BIT_KHX'                            : 1 << 3,
    u'FENCE_FD_BIT_KHX'                               : 1 << 4,
})
ExternalSemaphoreFeatureFlagsKHX = vkbuilder.Bitmask(u'ExternalSemaphoreFeatureFlagsKHX', {
    u'EXPORTABLE_BIT_KHX'                             : 1 << 0,
    u'IMPORTABLE_BIT_KHX'                             : 1 << 1,
})
SurfaceCounterFlagsEXT = vkbuilder.Bitmask(u'SurfaceCounterFlagsEXT', {
    u'VBLANK_EXT'                                     : 1 << 0,
})
DisplayPowerStateEXT = vkbuilder.Enumeration(u'DisplayPowerStateEXT', {
    u'OFF_EXT'                                        : 0,
    u'SUSPEND_EXT'                                    : 1,
    u'ON_EXT'                                         : 2,
})
DeviceEventTypeEXT = vkbuilder.Enumeration(u'DeviceEventTypeEXT', {
    u'DISPLAY_HOTPLUG_EXT'                            : 0,
})
DisplayEventTypeEXT = vkbuilder.Enumeration(u'DisplayEventTypeEXT', {
    u'FIRST_PIXEL_OUT_EXT'                            : 0,
})
PeerMemoryFeatureFlagsKHX = vkbuilder.Bitmask(u'PeerMemoryFeatureFlagsKHX', {
    u'COPY_SRC_BIT_KHX'                               : 1 << 0,
    u'COPY_DST_BIT_KHX'                               : 1 << 1,
    u'GENERIC_SRC_BIT_KHX'                            : 1 << 2,
    u'GENERIC_DST_BIT_KHX'                            : 1 << 3,
})
MemoryAllocateFlagsKHX = vkbuilder.Bitmask(u'MemoryAllocateFlagsKHX', {
    u'DEVICE_MASK_BIT_KHX'                            : 1 << 0,
})
DeviceGroupPresentModeFlagsKHX = vkbuilder.Bitmask(u'DeviceGroupPresentModeFlagsKHX', {
    u'LOCAL_BIT_KHX'                                  : 1 << 0,
    u'REMOTE_BIT_KHX'                                 : 1 << 1,
    u'SUM_BIT_KHX'                                    : 1 << 2,
    u'LOCAL_MULTI_DEVICE_BIT_KHX'                     : 1 << 3,
})
SwapchainCreateFlagsKHR = vkbuilder.Bitmask(u'SwapchainCreateFlagsKHR', {
})
ViewportCoordinateSwizzleNV = vkbuilder.Enumeration(u'ViewportCoordinateSwizzleNV', {
    u'POSITIVE_X_NV'                                  : 0,
    u'NEGATIVE_X_NV'                                  : 1,
    u'POSITIVE_Y_NV'                                  : 2,
    u'NEGATIVE_Y_NV'                                  : 3,
    u'POSITIVE_Z_NV'                                  : 4,
    u'NEGATIVE_Z_NV'                                  : 5,
    u'POSITIVE_W_NV'                                  : 6,
    u'NEGATIVE_W_NV'                                  : 7,
})
DiscardRectangleModeEXT = vkbuilder.Enumeration(u'DiscardRectangleModeEXT', {
    u'INCLUSIVE_EXT'                                  : 0,
    u'EXCLUSIVE_EXT'                                  : 1,
})
SubpassDescriptionFlags = vkbuilder.Bitmask(u'SubpassDescriptionFlags', {
})
class VulkanError(Exception):
    def __init__(self, result):
        self.result = result
    
    def __str__(self):
        return str(self.result)
ResultCheck = vkbuilder.AutoCheck(Result, VulkanError)
FramebufferCreateFlags = ctypes.c_uint32
QueryPoolCreateFlags = ctypes.c_uint32
RenderPassCreateFlags = ctypes.c_uint32
SamplerCreateFlags = ctypes.c_uint32
PipelineLayoutCreateFlags = ctypes.c_uint32
PipelineCacheCreateFlags = ctypes.c_uint32
PipelineDepthStencilStateCreateFlags = ctypes.c_uint32
PipelineDynamicStateCreateFlags = ctypes.c_uint32
PipelineColorBlendStateCreateFlags = ctypes.c_uint32
PipelineMultisampleStateCreateFlags = ctypes.c_uint32
PipelineRasterizationStateCreateFlags = ctypes.c_uint32
PipelineViewportStateCreateFlags = ctypes.c_uint32
PipelineTessellationStateCreateFlags = ctypes.c_uint32
PipelineInputAssemblyStateCreateFlags = ctypes.c_uint32
PipelineVertexInputStateCreateFlags = ctypes.c_uint32
PipelineShaderStageCreateFlags = ctypes.c_uint32
BufferViewCreateFlags = ctypes.c_uint32
InstanceCreateFlags = ctypes.c_uint32
DeviceCreateFlags = ctypes.c_uint32
DeviceQueueCreateFlags = ctypes.c_uint32
ImageViewCreateFlags = ctypes.c_uint32
SemaphoreCreateFlags = ctypes.c_uint32
ShaderModuleCreateFlags = ctypes.c_uint32
EventCreateFlags = ctypes.c_uint32
MemoryMapFlags = ctypes.c_uint32
DescriptorPoolResetFlags = ctypes.c_uint32
DescriptorUpdateTemplateCreateFlagsKHR = ctypes.c_uint32
DisplayModeCreateFlagsKHR = ctypes.c_uint32
DisplaySurfaceCreateFlagsKHR = ctypes.c_uint32
AndroidSurfaceCreateFlagsKHR = ctypes.c_uint32
MirSurfaceCreateFlagsKHR = ctypes.c_uint32
ViSurfaceCreateFlagsNN = ctypes.c_uint32
WaylandSurfaceCreateFlagsKHR = ctypes.c_uint32
Win32SurfaceCreateFlagsKHR = ctypes.c_uint32
XlibSurfaceCreateFlagsKHR = ctypes.c_uint32
XcbSurfaceCreateFlagsKHR = ctypes.c_uint32
IOSSurfaceCreateFlagsMVK = ctypes.c_uint32
MacOSSurfaceCreateFlagsMVK = ctypes.c_uint32
CommandPoolTrimFlagsKHR = ctypes.c_uint32
PipelineViewportSwizzleStateCreateFlagsNV = ctypes.c_uint32
PipelineDiscardRectangleStateCreateFlagsEXT = ctypes.c_uint32
Instance                 = vkbuilder.Handle(u'Instance')
PhysicalDevice           = vkbuilder.Handle(u'PhysicalDevice')
Device                   = vkbuilder.Handle(u'Device')
Queue                    = vkbuilder.Handle(u'Queue')
CommandBuffer            = vkbuilder.Handle(u'CommandBuffer')
DeviceMemory             = vkbuilder.Handle(u'DeviceMemory')
CommandPool              = vkbuilder.Handle(u'CommandPool')
Buffer                   = vkbuilder.Handle(u'Buffer')
BufferView               = vkbuilder.Handle(u'BufferView')
Image                    = vkbuilder.Handle(u'Image')
ImageView                = vkbuilder.Handle(u'ImageView')
ShaderModule             = vkbuilder.Handle(u'ShaderModule')
Pipeline                 = vkbuilder.Handle(u'Pipeline')
PipelineLayout           = vkbuilder.Handle(u'PipelineLayout')
Sampler                  = vkbuilder.Handle(u'Sampler')
DescriptorSet            = vkbuilder.Handle(u'DescriptorSet')
DescriptorSetLayout      = vkbuilder.Handle(u'DescriptorSetLayout')
DescriptorPool           = vkbuilder.Handle(u'DescriptorPool')
Fence                    = vkbuilder.Handle(u'Fence')
Semaphore                = vkbuilder.Handle(u'Semaphore')
Event                    = vkbuilder.Handle(u'Event')
QueryPool                = vkbuilder.Handle(u'QueryPool')
Framebuffer              = vkbuilder.Handle(u'Framebuffer')
RenderPass               = vkbuilder.Handle(u'RenderPass')
PipelineCache            = vkbuilder.Handle(u'PipelineCache')
ObjectTableNVX           = vkbuilder.Handle(u'ObjectTableNVX')
IndirectCommandsLayoutNVX = vkbuilder.Handle(u'IndirectCommandsLayoutNVX')
DescriptorUpdateTemplateKHR = vkbuilder.Handle(u'DescriptorUpdateTemplateKHR')
DisplayKHR               = vkbuilder.Handle(u'DisplayKHR')
DisplayModeKHR           = vkbuilder.Handle(u'DisplayModeKHR')
SurfaceKHR               = vkbuilder.Handle(u'SurfaceKHR')
SwapchainKHR             = vkbuilder.Handle(u'SwapchainKHR')
DebugReportCallbackEXT   = vkbuilder.Handle(u'DebugReportCallbackEXT')
FramebufferCreateFlags = ctypes.c_uint32
QueryPoolCreateFlags = ctypes.c_uint32
RenderPassCreateFlags = ctypes.c_uint32
SamplerCreateFlags = ctypes.c_uint32
PipelineLayoutCreateFlags = ctypes.c_uint32
PipelineCacheCreateFlags = ctypes.c_uint32
PipelineDepthStencilStateCreateFlags = ctypes.c_uint32
PipelineDynamicStateCreateFlags = ctypes.c_uint32
PipelineColorBlendStateCreateFlags = ctypes.c_uint32
PipelineMultisampleStateCreateFlags = ctypes.c_uint32
PipelineRasterizationStateCreateFlags = ctypes.c_uint32
PipelineViewportStateCreateFlags = ctypes.c_uint32
PipelineTessellationStateCreateFlags = ctypes.c_uint32
PipelineInputAssemblyStateCreateFlags = ctypes.c_uint32
PipelineVertexInputStateCreateFlags = ctypes.c_uint32
PipelineShaderStageCreateFlags = ctypes.c_uint32
BufferViewCreateFlags = ctypes.c_uint32
InstanceCreateFlags = ctypes.c_uint32
DeviceQueueCreateFlags = ctypes.c_uint32
DeviceCreateFlags = ctypes.c_uint32
PFN_InternalAllocationNotification = vkbuilder.FuncPointer(u'PFN_InternalAllocationNotification', None, [
    ctypes.c_void_p,
    ctypes.c_size_t,
    InternalAllocationType,
    SystemAllocationScope,
])
PFN_InternalFreeNotification = vkbuilder.FuncPointer(u'PFN_InternalFreeNotification', None, [
    ctypes.c_void_p,
    ctypes.c_size_t,
    InternalAllocationType,
    SystemAllocationScope,
])
PFN_ReallocationFunction = vkbuilder.FuncPointer(u'PFN_ReallocationFunction', ctypes.c_void_p, [
    ctypes.c_void_p,
    ctypes.c_void_p,
    ctypes.c_size_t,
    ctypes.c_size_t,
    SystemAllocationScope,
])
PFN_AllocationFunction = vkbuilder.FuncPointer(u'PFN_AllocationFunction', ctypes.c_void_p, [
    ctypes.c_void_p,
    ctypes.c_size_t,
    ctypes.c_size_t,
    SystemAllocationScope,
])
PFN_FreeFunction = vkbuilder.FuncPointer(u'PFN_FreeFunction', None, [
    ctypes.c_void_p,
    ctypes.c_void_p,
])
PFN_VoidFunction = vkbuilder.FuncPointer(u'PFN_VoidFunction', None, [
])
PFN_DebugReportCallbackEXT = vkbuilder.FuncPointer(u'PFN_DebugReportCallbackEXT', Bool32, [
    DebugReportFlagsEXT,
    DebugReportObjectTypeEXT,
    ctypes.c_uint64,
    ctypes.c_size_t,
    ctypes.c_int32,
    ctypes.c_char_p,
    ctypes.c_char_p,
    ctypes.c_void_p,
])
Offset2D = vkbuilder.Structure(u'Offset2D')
Offset3D = vkbuilder.Structure(u'Offset3D')
Extent2D = vkbuilder.Structure(u'Extent2D')
Extent3D = vkbuilder.Structure(u'Extent3D')
Viewport = vkbuilder.Structure(u'Viewport')
Rect2D = vkbuilder.Structure(u'Rect2D')
Rect3D = vkbuilder.Structure(u'Rect3D')
ClearRect = vkbuilder.Structure(u'ClearRect')
ComponentMapping = vkbuilder.Structure(u'ComponentMapping')
PhysicalDeviceProperties = vkbuilder.Structure(u'PhysicalDeviceProperties')
ExtensionProperties = vkbuilder.Structure(u'ExtensionProperties')
LayerProperties = vkbuilder.Structure(u'LayerProperties')
ApplicationInfo = vkbuilder.Structure(u'ApplicationInfo')
AllocationCallbacks = vkbuilder.Structure(u'AllocationCallbacks')
DeviceQueueCreateInfo = vkbuilder.Structure(u'DeviceQueueCreateInfo')
DeviceCreateInfo = vkbuilder.Structure(u'DeviceCreateInfo')
InstanceCreateInfo = vkbuilder.Structure(u'InstanceCreateInfo')
QueueFamilyProperties = vkbuilder.Structure(u'QueueFamilyProperties')
PhysicalDeviceMemoryProperties = vkbuilder.Structure(u'PhysicalDeviceMemoryProperties')
MemoryAllocateInfo = vkbuilder.Structure(u'MemoryAllocateInfo')
MemoryRequirements = vkbuilder.Structure(u'MemoryRequirements')
SparseImageFormatProperties = vkbuilder.Structure(u'SparseImageFormatProperties')
SparseImageMemoryRequirements = vkbuilder.Structure(u'SparseImageMemoryRequirements')
MemoryType = vkbuilder.Structure(u'MemoryType')
MemoryHeap = vkbuilder.Structure(u'MemoryHeap')
MappedMemoryRange = vkbuilder.Structure(u'MappedMemoryRange')
FormatProperties = vkbuilder.Structure(u'FormatProperties')
ImageFormatProperties = vkbuilder.Structure(u'ImageFormatProperties')
DescriptorBufferInfo = vkbuilder.Structure(u'DescriptorBufferInfo')
DescriptorImageInfo = vkbuilder.Structure(u'DescriptorImageInfo')
WriteDescriptorSet = vkbuilder.Structure(u'WriteDescriptorSet')
CopyDescriptorSet = vkbuilder.Structure(u'CopyDescriptorSet')
BufferCreateInfo = vkbuilder.Structure(u'BufferCreateInfo')
BufferViewCreateInfo = vkbuilder.Structure(u'BufferViewCreateInfo')
ImageSubresource = vkbuilder.Structure(u'ImageSubresource')
ImageSubresourceLayers = vkbuilder.Structure(u'ImageSubresourceLayers')
ImageSubresourceRange = vkbuilder.Structure(u'ImageSubresourceRange')
MemoryBarrier = vkbuilder.Structure(u'MemoryBarrier')
BufferMemoryBarrier = vkbuilder.Structure(u'BufferMemoryBarrier')
ImageMemoryBarrier = vkbuilder.Structure(u'ImageMemoryBarrier')
ImageCreateInfo = vkbuilder.Structure(u'ImageCreateInfo')
SubresourceLayout = vkbuilder.Structure(u'SubresourceLayout')
ImageViewCreateInfo = vkbuilder.Structure(u'ImageViewCreateInfo')
BufferCopy = vkbuilder.Structure(u'BufferCopy')
SparseMemoryBind = vkbuilder.Structure(u'SparseMemoryBind')
SparseImageMemoryBind = vkbuilder.Structure(u'SparseImageMemoryBind')
SparseBufferMemoryBindInfo = vkbuilder.Structure(u'SparseBufferMemoryBindInfo')
SparseImageOpaqueMemoryBindInfo = vkbuilder.Structure(u'SparseImageOpaqueMemoryBindInfo')
SparseImageMemoryBindInfo = vkbuilder.Structure(u'SparseImageMemoryBindInfo')
BindSparseInfo = vkbuilder.Structure(u'BindSparseInfo')
ImageCopy = vkbuilder.Structure(u'ImageCopy')
ImageBlit = vkbuilder.Structure(u'ImageBlit')
BufferImageCopy = vkbuilder.Structure(u'BufferImageCopy')
ImageResolve = vkbuilder.Structure(u'ImageResolve')
ShaderModuleCreateInfo = vkbuilder.Structure(u'ShaderModuleCreateInfo')
DescriptorSetLayoutBinding = vkbuilder.Structure(u'DescriptorSetLayoutBinding')
DescriptorSetLayoutCreateInfo = vkbuilder.Structure(u'DescriptorSetLayoutCreateInfo')
DescriptorPoolSize = vkbuilder.Structure(u'DescriptorPoolSize')
DescriptorPoolCreateInfo = vkbuilder.Structure(u'DescriptorPoolCreateInfo')
DescriptorSetAllocateInfo = vkbuilder.Structure(u'DescriptorSetAllocateInfo')
SpecializationMapEntry = vkbuilder.Structure(u'SpecializationMapEntry')
SpecializationInfo = vkbuilder.Structure(u'SpecializationInfo')
PipelineShaderStageCreateInfo = vkbuilder.Structure(u'PipelineShaderStageCreateInfo')
ComputePipelineCreateInfo = vkbuilder.Structure(u'ComputePipelineCreateInfo')
VertexInputBindingDescription = vkbuilder.Structure(u'VertexInputBindingDescription')
VertexInputAttributeDescription = vkbuilder.Structure(u'VertexInputAttributeDescription')
PipelineVertexInputStateCreateInfo = vkbuilder.Structure(u'PipelineVertexInputStateCreateInfo')
PipelineInputAssemblyStateCreateInfo = vkbuilder.Structure(u'PipelineInputAssemblyStateCreateInfo')
PipelineTessellationStateCreateInfo = vkbuilder.Structure(u'PipelineTessellationStateCreateInfo')
PipelineViewportStateCreateInfo = vkbuilder.Structure(u'PipelineViewportStateCreateInfo')
PipelineRasterizationStateCreateInfo = vkbuilder.Structure(u'PipelineRasterizationStateCreateInfo')
PipelineMultisampleStateCreateInfo = vkbuilder.Structure(u'PipelineMultisampleStateCreateInfo')
PipelineColorBlendAttachmentState = vkbuilder.Structure(u'PipelineColorBlendAttachmentState')
PipelineColorBlendStateCreateInfo = vkbuilder.Structure(u'PipelineColorBlendStateCreateInfo')
PipelineDynamicStateCreateInfo = vkbuilder.Structure(u'PipelineDynamicStateCreateInfo')
StencilOpState = vkbuilder.Structure(u'StencilOpState')
PipelineDepthStencilStateCreateInfo = vkbuilder.Structure(u'PipelineDepthStencilStateCreateInfo')
GraphicsPipelineCreateInfo = vkbuilder.Structure(u'GraphicsPipelineCreateInfo')
PipelineCacheCreateInfo = vkbuilder.Structure(u'PipelineCacheCreateInfo')
PushConstantRange = vkbuilder.Structure(u'PushConstantRange')
PipelineLayoutCreateInfo = vkbuilder.Structure(u'PipelineLayoutCreateInfo')
SamplerCreateInfo = vkbuilder.Structure(u'SamplerCreateInfo')
CommandPoolCreateInfo = vkbuilder.Structure(u'CommandPoolCreateInfo')
CommandBufferAllocateInfo = vkbuilder.Structure(u'CommandBufferAllocateInfo')
CommandBufferInheritanceInfo = vkbuilder.Structure(u'CommandBufferInheritanceInfo')
CommandBufferBeginInfo = vkbuilder.Structure(u'CommandBufferBeginInfo')
RenderPassBeginInfo = vkbuilder.Structure(u'RenderPassBeginInfo')
ClearColorValue = vkbuilder.Union(u'ClearColorValue')
ClearDepthStencilValue = vkbuilder.Structure(u'ClearDepthStencilValue')
ClearValue = vkbuilder.Union(u'ClearValue')
ClearAttachment = vkbuilder.Structure(u'ClearAttachment')
AttachmentDescription = vkbuilder.Structure(u'AttachmentDescription')
AttachmentReference = vkbuilder.Structure(u'AttachmentReference')
SubpassDescription = vkbuilder.Structure(u'SubpassDescription')
SubpassDependency = vkbuilder.Structure(u'SubpassDependency')
RenderPassCreateInfo = vkbuilder.Structure(u'RenderPassCreateInfo')
EventCreateInfo = vkbuilder.Structure(u'EventCreateInfo')
FenceCreateInfo = vkbuilder.Structure(u'FenceCreateInfo')
PhysicalDeviceFeatures = vkbuilder.Structure(u'PhysicalDeviceFeatures')
PhysicalDeviceSparseProperties = vkbuilder.Structure(u'PhysicalDeviceSparseProperties')
PhysicalDeviceLimits = vkbuilder.Structure(u'PhysicalDeviceLimits')
SemaphoreCreateInfo = vkbuilder.Structure(u'SemaphoreCreateInfo')
QueryPoolCreateInfo = vkbuilder.Structure(u'QueryPoolCreateInfo')
FramebufferCreateInfo = vkbuilder.Structure(u'FramebufferCreateInfo')
DrawIndirectCommand = vkbuilder.Structure(u'DrawIndirectCommand')
DrawIndexedIndirectCommand = vkbuilder.Structure(u'DrawIndexedIndirectCommand')
DispatchIndirectCommand = vkbuilder.Structure(u'DispatchIndirectCommand')
SubmitInfo = vkbuilder.Structure(u'SubmitInfo')
DisplayPropertiesKHR = vkbuilder.Structure(u'DisplayPropertiesKHR')
DisplayPlanePropertiesKHR = vkbuilder.Structure(u'DisplayPlanePropertiesKHR')
DisplayModeParametersKHR = vkbuilder.Structure(u'DisplayModeParametersKHR')
DisplayModePropertiesKHR = vkbuilder.Structure(u'DisplayModePropertiesKHR')
DisplayModeCreateInfoKHR = vkbuilder.Structure(u'DisplayModeCreateInfoKHR')
DisplayPlaneCapabilitiesKHR = vkbuilder.Structure(u'DisplayPlaneCapabilitiesKHR')
DisplaySurfaceCreateInfoKHR = vkbuilder.Structure(u'DisplaySurfaceCreateInfoKHR')
DisplayPresentInfoKHR = vkbuilder.Structure(u'DisplayPresentInfoKHR')
SurfaceCapabilitiesKHR = vkbuilder.Structure(u'SurfaceCapabilitiesKHR')
AndroidSurfaceCreateInfoKHR = vkbuilder.Structure(u'AndroidSurfaceCreateInfoKHR')
MirSurfaceCreateInfoKHR = vkbuilder.Structure(u'MirSurfaceCreateInfoKHR')
ViSurfaceCreateInfoNN = vkbuilder.Structure(u'ViSurfaceCreateInfoNN')
WaylandSurfaceCreateInfoKHR = vkbuilder.Structure(u'WaylandSurfaceCreateInfoKHR')
Win32SurfaceCreateInfoKHR = vkbuilder.Structure(u'Win32SurfaceCreateInfoKHR')
XlibSurfaceCreateInfoKHR = vkbuilder.Structure(u'XlibSurfaceCreateInfoKHR')
XcbSurfaceCreateInfoKHR = vkbuilder.Structure(u'XcbSurfaceCreateInfoKHR')
SurfaceFormatKHR = vkbuilder.Structure(u'SurfaceFormatKHR')
SwapchainCreateInfoKHR = vkbuilder.Structure(u'SwapchainCreateInfoKHR')
PresentInfoKHR = vkbuilder.Structure(u'PresentInfoKHR')
DebugReportCallbackCreateInfoEXT = vkbuilder.Structure(u'DebugReportCallbackCreateInfoEXT')
ValidationFlagsEXT = vkbuilder.Structure(u'ValidationFlagsEXT')
PipelineRasterizationStateRasterizationOrderAMD = vkbuilder.Structure(u'PipelineRasterizationStateRasterizationOrderAMD')
DebugMarkerObjectNameInfoEXT = vkbuilder.Structure(u'DebugMarkerObjectNameInfoEXT')
DebugMarkerObjectTagInfoEXT = vkbuilder.Structure(u'DebugMarkerObjectTagInfoEXT')
DebugMarkerMarkerInfoEXT = vkbuilder.Structure(u'DebugMarkerMarkerInfoEXT')
DedicatedAllocationImageCreateInfoNV = vkbuilder.Structure(u'DedicatedAllocationImageCreateInfoNV')
DedicatedAllocationBufferCreateInfoNV = vkbuilder.Structure(u'DedicatedAllocationBufferCreateInfoNV')
DedicatedAllocationMemoryAllocateInfoNV = vkbuilder.Structure(u'DedicatedAllocationMemoryAllocateInfoNV')
ExternalImageFormatPropertiesNV = vkbuilder.Structure(u'ExternalImageFormatPropertiesNV')
ExternalMemoryImageCreateInfoNV = vkbuilder.Structure(u'ExternalMemoryImageCreateInfoNV')
ExportMemoryAllocateInfoNV = vkbuilder.Structure(u'ExportMemoryAllocateInfoNV')
ImportMemoryWin32HandleInfoNV = vkbuilder.Structure(u'ImportMemoryWin32HandleInfoNV')
ExportMemoryWin32HandleInfoNV = vkbuilder.Structure(u'ExportMemoryWin32HandleInfoNV')
Win32KeyedMutexAcquireReleaseInfoNV = vkbuilder.Structure(u'Win32KeyedMutexAcquireReleaseInfoNV')
DeviceGeneratedCommandsFeaturesNVX = vkbuilder.Structure(u'DeviceGeneratedCommandsFeaturesNVX')
DeviceGeneratedCommandsLimitsNVX = vkbuilder.Structure(u'DeviceGeneratedCommandsLimitsNVX')
IndirectCommandsTokenNVX = vkbuilder.Structure(u'IndirectCommandsTokenNVX')
IndirectCommandsLayoutTokenNVX = vkbuilder.Structure(u'IndirectCommandsLayoutTokenNVX')
IndirectCommandsLayoutCreateInfoNVX = vkbuilder.Structure(u'IndirectCommandsLayoutCreateInfoNVX')
CmdProcessCommandsInfoNVX = vkbuilder.Structure(u'CmdProcessCommandsInfoNVX')
CmdReserveSpaceForCommandsInfoNVX = vkbuilder.Structure(u'CmdReserveSpaceForCommandsInfoNVX')
ObjectTableCreateInfoNVX = vkbuilder.Structure(u'ObjectTableCreateInfoNVX')
ObjectTableEntryNVX = vkbuilder.Structure(u'ObjectTableEntryNVX')
ObjectTablePipelineEntryNVX = vkbuilder.Structure(u'ObjectTablePipelineEntryNVX')
ObjectTableDescriptorSetEntryNVX = vkbuilder.Structure(u'ObjectTableDescriptorSetEntryNVX')
ObjectTableVertexBufferEntryNVX = vkbuilder.Structure(u'ObjectTableVertexBufferEntryNVX')
ObjectTableIndexBufferEntryNVX = vkbuilder.Structure(u'ObjectTableIndexBufferEntryNVX')
ObjectTablePushConstantEntryNVX = vkbuilder.Structure(u'ObjectTablePushConstantEntryNVX')
PhysicalDeviceFeatures2KHR = vkbuilder.Structure(u'PhysicalDeviceFeatures2KHR')
PhysicalDeviceProperties2KHR = vkbuilder.Structure(u'PhysicalDeviceProperties2KHR')
FormatProperties2KHR = vkbuilder.Structure(u'FormatProperties2KHR')
ImageFormatProperties2KHR = vkbuilder.Structure(u'ImageFormatProperties2KHR')
PhysicalDeviceImageFormatInfo2KHR = vkbuilder.Structure(u'PhysicalDeviceImageFormatInfo2KHR')
QueueFamilyProperties2KHR = vkbuilder.Structure(u'QueueFamilyProperties2KHR')
PhysicalDeviceMemoryProperties2KHR = vkbuilder.Structure(u'PhysicalDeviceMemoryProperties2KHR')
SparseImageFormatProperties2KHR = vkbuilder.Structure(u'SparseImageFormatProperties2KHR')
PhysicalDeviceSparseImageFormatInfo2KHR = vkbuilder.Structure(u'PhysicalDeviceSparseImageFormatInfo2KHR')
PhysicalDevicePushDescriptorPropertiesKHR = vkbuilder.Structure(u'PhysicalDevicePushDescriptorPropertiesKHR')
ExternalMemoryPropertiesKHX = vkbuilder.Structure(u'ExternalMemoryPropertiesKHX')
PhysicalDeviceExternalImageFormatInfoKHX = vkbuilder.Structure(u'PhysicalDeviceExternalImageFormatInfoKHX')
ExternalImageFormatPropertiesKHX = vkbuilder.Structure(u'ExternalImageFormatPropertiesKHX')
PhysicalDeviceExternalBufferInfoKHX = vkbuilder.Structure(u'PhysicalDeviceExternalBufferInfoKHX')
ExternalBufferPropertiesKHX = vkbuilder.Structure(u'ExternalBufferPropertiesKHX')
PhysicalDeviceIDPropertiesKHX = vkbuilder.Structure(u'PhysicalDeviceIDPropertiesKHX')
ExternalMemoryImageCreateInfoKHX = vkbuilder.Structure(u'ExternalMemoryImageCreateInfoKHX')
ExternalMemoryBufferCreateInfoKHX = vkbuilder.Structure(u'ExternalMemoryBufferCreateInfoKHX')
ExportMemoryAllocateInfoKHX = vkbuilder.Structure(u'ExportMemoryAllocateInfoKHX')
ImportMemoryWin32HandleInfoKHX = vkbuilder.Structure(u'ImportMemoryWin32HandleInfoKHX')
ExportMemoryWin32HandleInfoKHX = vkbuilder.Structure(u'ExportMemoryWin32HandleInfoKHX')
MemoryWin32HandlePropertiesKHX = vkbuilder.Structure(u'MemoryWin32HandlePropertiesKHX')
ImportMemoryFdInfoKHX = vkbuilder.Structure(u'ImportMemoryFdInfoKHX')
MemoryFdPropertiesKHX = vkbuilder.Structure(u'MemoryFdPropertiesKHX')
Win32KeyedMutexAcquireReleaseInfoKHX = vkbuilder.Structure(u'Win32KeyedMutexAcquireReleaseInfoKHX')
PhysicalDeviceExternalSemaphoreInfoKHX = vkbuilder.Structure(u'PhysicalDeviceExternalSemaphoreInfoKHX')
ExternalSemaphorePropertiesKHX = vkbuilder.Structure(u'ExternalSemaphorePropertiesKHX')
ExportSemaphoreCreateInfoKHX = vkbuilder.Structure(u'ExportSemaphoreCreateInfoKHX')
ImportSemaphoreWin32HandleInfoKHX = vkbuilder.Structure(u'ImportSemaphoreWin32HandleInfoKHX')
ExportSemaphoreWin32HandleInfoKHX = vkbuilder.Structure(u'ExportSemaphoreWin32HandleInfoKHX')
D3D12FenceSubmitInfoKHX = vkbuilder.Structure(u'D3D12FenceSubmitInfoKHX')
ImportSemaphoreFdInfoKHX = vkbuilder.Structure(u'ImportSemaphoreFdInfoKHX')
PhysicalDeviceMultiviewFeaturesKHX = vkbuilder.Structure(u'PhysicalDeviceMultiviewFeaturesKHX')
PhysicalDeviceMultiviewPropertiesKHX = vkbuilder.Structure(u'PhysicalDeviceMultiviewPropertiesKHX')
RenderPassMultiviewCreateInfoKHX = vkbuilder.Structure(u'RenderPassMultiviewCreateInfoKHX')
SurfaceCapabilities2EXT = vkbuilder.Structure(u'SurfaceCapabilities2EXT')
DisplayPowerInfoEXT = vkbuilder.Structure(u'DisplayPowerInfoEXT')
DeviceEventInfoEXT = vkbuilder.Structure(u'DeviceEventInfoEXT')
DisplayEventInfoEXT = vkbuilder.Structure(u'DisplayEventInfoEXT')
SwapchainCounterCreateInfoEXT = vkbuilder.Structure(u'SwapchainCounterCreateInfoEXT')
PhysicalDeviceGroupPropertiesKHX = vkbuilder.Structure(u'PhysicalDeviceGroupPropertiesKHX')
MemoryAllocateFlagsInfoKHX = vkbuilder.Structure(u'MemoryAllocateFlagsInfoKHX')
BindBufferMemoryInfoKHX = vkbuilder.Structure(u'BindBufferMemoryInfoKHX')
BindImageMemoryInfoKHX = vkbuilder.Structure(u'BindImageMemoryInfoKHX')
DeviceGroupRenderPassBeginInfoKHX = vkbuilder.Structure(u'DeviceGroupRenderPassBeginInfoKHX')
DeviceGroupCommandBufferBeginInfoKHX = vkbuilder.Structure(u'DeviceGroupCommandBufferBeginInfoKHX')
DeviceGroupSubmitInfoKHX = vkbuilder.Structure(u'DeviceGroupSubmitInfoKHX')
DeviceGroupBindSparseInfoKHX = vkbuilder.Structure(u'DeviceGroupBindSparseInfoKHX')
DeviceGroupPresentCapabilitiesKHX = vkbuilder.Structure(u'DeviceGroupPresentCapabilitiesKHX')
ImageSwapchainCreateInfoKHX = vkbuilder.Structure(u'ImageSwapchainCreateInfoKHX')
BindImageMemorySwapchainInfoKHX = vkbuilder.Structure(u'BindImageMemorySwapchainInfoKHX')
AcquireNextImageInfoKHX = vkbuilder.Structure(u'AcquireNextImageInfoKHX')
DeviceGroupPresentInfoKHX = vkbuilder.Structure(u'DeviceGroupPresentInfoKHX')
DeviceGroupDeviceCreateInfoKHX = vkbuilder.Structure(u'DeviceGroupDeviceCreateInfoKHX')
DeviceGroupSwapchainCreateInfoKHX = vkbuilder.Structure(u'DeviceGroupSwapchainCreateInfoKHX')
DescriptorUpdateTemplateEntryKHR = vkbuilder.Structure(u'DescriptorUpdateTemplateEntryKHR')
DescriptorUpdateTemplateCreateInfoKHR = vkbuilder.Structure(u'DescriptorUpdateTemplateCreateInfoKHR')
XYColorEXT = vkbuilder.Structure(u'XYColorEXT')
HdrMetadataEXT = vkbuilder.Structure(u'HdrMetadataEXT')
RefreshCycleDurationGOOGLE = vkbuilder.Structure(u'RefreshCycleDurationGOOGLE')
PastPresentationTimingGOOGLE = vkbuilder.Structure(u'PastPresentationTimingGOOGLE')
PresentTimesInfoGOOGLE = vkbuilder.Structure(u'PresentTimesInfoGOOGLE')
PresentTimeGOOGLE = vkbuilder.Structure(u'PresentTimeGOOGLE')
IOSSurfaceCreateInfoMVK = vkbuilder.Structure(u'IOSSurfaceCreateInfoMVK')
MacOSSurfaceCreateInfoMVK = vkbuilder.Structure(u'MacOSSurfaceCreateInfoMVK')
ViewportWScalingNV = vkbuilder.Structure(u'ViewportWScalingNV')
PipelineViewportWScalingStateCreateInfoNV = vkbuilder.Structure(u'PipelineViewportWScalingStateCreateInfoNV')
ViewportSwizzleNV = vkbuilder.Structure(u'ViewportSwizzleNV')
PipelineViewportSwizzleStateCreateInfoNV = vkbuilder.Structure(u'PipelineViewportSwizzleStateCreateInfoNV')
PhysicalDeviceDiscardRectanglePropertiesEXT = vkbuilder.Structure(u'PhysicalDeviceDiscardRectanglePropertiesEXT')
PipelineDiscardRectangleStateCreateInfoEXT = vkbuilder.Structure(u'PipelineDiscardRectangleStateCreateInfoEXT')
PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX = vkbuilder.Structure(u'PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX')

Offset2D.declare([
    (u'x', ctypes.c_int32),
    (u'y', ctypes.c_int32),
])
Offset3D.declare([
    (u'x', ctypes.c_int32),
    (u'y', ctypes.c_int32),
    (u'z', ctypes.c_int32),
])
Extent2D.declare([
    (u'width', ctypes.c_uint32),
    (u'height', ctypes.c_uint32),
])
Extent3D.declare([
    (u'width', ctypes.c_uint32),
    (u'height', ctypes.c_uint32),
    (u'depth', ctypes.c_uint32),
])
Viewport.declare([
    (u'x', ctypes.c_float),
    (u'y', ctypes.c_float),
    (u'width', ctypes.c_float),
    (u'height', ctypes.c_float),
    (u'minDepth', ctypes.c_float),
    (u'maxDepth', ctypes.c_float),
])
Rect2D.declare([
    (u'offset', Offset2D),
    (u'extent', Extent2D),
])
Rect3D.declare([
    (u'offset', Offset3D),
    (u'extent', Extent3D),
])
ClearRect.declare([
    (u'rect', Rect2D),
    (u'baseArrayLayer', ctypes.c_uint32),
    (u'layerCount', ctypes.c_uint32),
])
ComponentMapping.declare([
    (u'r', ComponentSwizzle),
    (u'g', ComponentSwizzle),
    (u'b', ComponentSwizzle),
    (u'a', ComponentSwizzle),
])
PhysicalDeviceProperties.declare([
    (u'apiVersion', ctypes.c_uint32),
    (u'driverVersion', ctypes.c_uint32),
    (u'vendorID', ctypes.c_uint32),
    (u'deviceID', ctypes.c_uint32),
    (u'deviceType', PhysicalDeviceType),
    (u'deviceName', vkbuilder.Array(ctypes.c_char, MAX_PHYSICAL_DEVICE_NAME_SIZE)),
    (u'pipelineCacheUUID', vkbuilder.Array(ctypes.c_uint8, UUID_SIZE)),
    (u'limits', PhysicalDeviceLimits),
    (u'sparseProperties', PhysicalDeviceSparseProperties),
])
ExtensionProperties.declare([
    (u'extensionName', vkbuilder.Array(ctypes.c_char, MAX_EXTENSION_NAME_SIZE)),
    (u'specVersion', ctypes.c_uint32),
])
LayerProperties.declare([
    (u'layerName', vkbuilder.Array(ctypes.c_char, MAX_EXTENSION_NAME_SIZE)),
    (u'specVersion', ctypes.c_uint32),
    (u'implementationVersion', ctypes.c_uint32),
    (u'description', vkbuilder.Array(ctypes.c_char, MAX_DESCRIPTION_SIZE)),
])
ApplicationInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'pApplicationName', ctypes.c_char_p),
    (u'applicationVersion', ctypes.c_uint32),
    (u'pEngineName', ctypes.c_char_p),
    (u'engineVersion', ctypes.c_uint32),
    (u'apiVersion', ctypes.c_uint32),
])
ApplicationInfo.declare_aliases([
    (u'applicationName', u'pApplicationName'),
    (u'engineName', u'pEngineName'),
])
ApplicationInfo.sType = u'APPLICATION_INFO'
AllocationCallbacks.declare([
    (u'pUserData', ctypes.c_void_p),
    (u'pfnAllocation', PFN_AllocationFunction),
    (u'pfnReallocation', PFN_ReallocationFunction),
    (u'pfnFree', PFN_FreeFunction),
    (u'pfnInternalAllocation', PFN_InternalAllocationNotification),
    (u'pfnInternalFree', PFN_InternalFreeNotification),
])
AllocationCallbacks.declare_aliases([
    (u'userData', u'pUserData'),
])
DeviceQueueCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', DeviceQueueCreateFlags),
    (u'queueFamilyIndex', ctypes.c_uint32),
    (u'queueCount', ctypes.c_uint32),
    (u'pQueuePriorities', vkbuilder.Pointer(ctypes.c_float)),
])
DeviceQueueCreateInfo.declare_autoarrays([
    (u'queuePriorities', (u'queueCount', u'pQueuePriorities')),
])
DeviceQueueCreateInfo.sType = u'DEVICE_QUEUE_CREATE_INFO'
DeviceCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', DeviceCreateFlags),
    (u'queueCreateInfoCount', ctypes.c_uint32),
    (u'pQueueCreateInfos', vkbuilder.Pointer(DeviceQueueCreateInfo)),
    (u'enabledLayerCount', ctypes.c_uint32),
    (u'ppEnabledLayerNames', vkbuilder.Pointer(ctypes.c_char_p)),
    (u'enabledExtensionCount', ctypes.c_uint32),
    (u'ppEnabledExtensionNames', vkbuilder.Pointer(ctypes.c_char_p)),
    (u'pEnabledFeatures', vkbuilder.Pointer(PhysicalDeviceFeatures)),
])
DeviceCreateInfo.declare_autoarrays([
    (u'queueCreateInfos', (u'queueCreateInfoCount', u'pQueueCreateInfos')),
    (u'enabledLayerNames', (u'enabledLayerCount', u'ppEnabledLayerNames')),
    (u'enabledExtensionNames', (u'enabledExtensionCount', u'ppEnabledExtensionNames')),
])
DeviceCreateInfo.declare_aliases([
    (u'enabledFeatures', u'pEnabledFeatures'),
])
DeviceCreateInfo.sType = u'DEVICE_CREATE_INFO'
InstanceCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', InstanceCreateFlags),
    (u'pApplicationInfo', vkbuilder.Pointer(ApplicationInfo)),
    (u'enabledLayerCount', ctypes.c_uint32),
    (u'ppEnabledLayerNames', vkbuilder.Pointer(ctypes.c_char_p)),
    (u'enabledExtensionCount', ctypes.c_uint32),
    (u'ppEnabledExtensionNames', vkbuilder.Pointer(ctypes.c_char_p)),
])
InstanceCreateInfo.declare_autoarrays([
    (u'enabledLayerNames', (u'enabledLayerCount', u'ppEnabledLayerNames')),
    (u'enabledExtensionNames', (u'enabledExtensionCount', u'ppEnabledExtensionNames')),
])
InstanceCreateInfo.declare_aliases([
    (u'applicationInfo', u'pApplicationInfo'),
])
InstanceCreateInfo.sType = u'INSTANCE_CREATE_INFO'
QueueFamilyProperties.declare([
    (u'queueFlags', QueueFlags),
    (u'queueCount', ctypes.c_uint32),
    (u'timestampValidBits', ctypes.c_uint32),
    (u'minImageTransferGranularity', Extent3D),
])
PhysicalDeviceMemoryProperties.declare([
    (u'memoryTypeCount', ctypes.c_uint32),
    (u'memoryTypes', vkbuilder.Array(MemoryType, MAX_MEMORY_TYPES)),
    (u'memoryHeapCount', ctypes.c_uint32),
    (u'memoryHeaps', vkbuilder.Array(MemoryHeap, MAX_MEMORY_HEAPS)),
])
MemoryAllocateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'allocationSize', DeviceSize),
    (u'memoryTypeIndex', ctypes.c_uint32),
])
MemoryAllocateInfo.sType = u'MEMORY_ALLOCATE_INFO'
MemoryRequirements.declare([
    (u'size', DeviceSize),
    (u'alignment', DeviceSize),
    (u'memoryTypeBits', ctypes.c_uint32),
])
SparseImageFormatProperties.declare([
    (u'aspectMask', ImageAspectFlags),
    (u'imageGranularity', Extent3D),
    (u'flags', SparseImageFormatFlags),
])
SparseImageMemoryRequirements.declare([
    (u'formatProperties', SparseImageFormatProperties),
    (u'imageMipTailFirstLod', ctypes.c_uint32),
    (u'imageMipTailSize', DeviceSize),
    (u'imageMipTailOffset', DeviceSize),
    (u'imageMipTailStride', DeviceSize),
])
MemoryType.declare([
    (u'propertyFlags', MemoryPropertyFlags),
    (u'heapIndex', ctypes.c_uint32),
])
MemoryHeap.declare([
    (u'size', DeviceSize),
    (u'flags', MemoryHeapFlags),
])
MappedMemoryRange.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'memory', DeviceMemory),
    (u'offset', DeviceSize),
    (u'size', DeviceSize),
])
MappedMemoryRange.sType = u'MAPPED_MEMORY_RANGE'
FormatProperties.declare([
    (u'linearTilingFeatures', FormatFeatureFlags),
    (u'optimalTilingFeatures', FormatFeatureFlags),
    (u'bufferFeatures', FormatFeatureFlags),
])
ImageFormatProperties.declare([
    (u'maxExtent', Extent3D),
    (u'maxMipLevels', ctypes.c_uint32),
    (u'maxArrayLayers', ctypes.c_uint32),
    (u'sampleCounts', SampleCountFlags),
    (u'maxResourceSize', DeviceSize),
])
DescriptorBufferInfo.declare([
    (u'buffer', Buffer),
    (u'offset', DeviceSize),
    (u'range', DeviceSize),
])
DescriptorImageInfo.declare([
    (u'sampler', Sampler),
    (u'imageView', ImageView),
    (u'imageLayout', ImageLayout),
])
WriteDescriptorSet.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'dstSet', DescriptorSet),
    (u'dstBinding', ctypes.c_uint32),
    (u'dstArrayElement', ctypes.c_uint32),
    (u'descriptorCount', ctypes.c_uint32),
    (u'descriptorType', DescriptorType),
    (u'pImageInfo', vkbuilder.Pointer(DescriptorImageInfo)),
    (u'pBufferInfo', vkbuilder.Pointer(DescriptorBufferInfo)),
    (u'pTexelBufferView', vkbuilder.Pointer(BufferView)),
])
WriteDescriptorSet.declare_autoarrays([
    (u'imageInfo', (u'descriptorCount', u'pImageInfo')),
    (u'bufferInfo', (u'descriptorCount', u'pBufferInfo')),
    (u'texelBufferView', (u'descriptorCount', u'pTexelBufferView')),
])
WriteDescriptorSet.sType = u'WRITE_DESCRIPTOR_SET'
CopyDescriptorSet.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'srcSet', DescriptorSet),
    (u'srcBinding', ctypes.c_uint32),
    (u'srcArrayElement', ctypes.c_uint32),
    (u'dstSet', DescriptorSet),
    (u'dstBinding', ctypes.c_uint32),
    (u'dstArrayElement', ctypes.c_uint32),
    (u'descriptorCount', ctypes.c_uint32),
])
CopyDescriptorSet.sType = u'COPY_DESCRIPTOR_SET'
BufferCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', BufferCreateFlags),
    (u'size', DeviceSize),
    (u'usage', BufferUsageFlags),
    (u'sharingMode', SharingMode),
    (u'queueFamilyIndexCount', ctypes.c_uint32),
    (u'pQueueFamilyIndices', vkbuilder.Pointer(ctypes.c_uint32)),
])
BufferCreateInfo.declare_autoarrays([
    (u'queueFamilyIndices', (u'queueFamilyIndexCount', u'pQueueFamilyIndices')),
])
BufferCreateInfo.sType = u'BUFFER_CREATE_INFO'
BufferViewCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', BufferViewCreateFlags),
    (u'buffer', Buffer),
    (u'format', Format),
    (u'offset', DeviceSize),
    (u'range', DeviceSize),
])
BufferViewCreateInfo.sType = u'BUFFER_VIEW_CREATE_INFO'
ImageSubresource.declare([
    (u'aspectMask', ImageAspectFlags),
    (u'mipLevel', ctypes.c_uint32),
    (u'arrayLayer', ctypes.c_uint32),
])
ImageSubresourceLayers.declare([
    (u'aspectMask', ImageAspectFlags),
    (u'mipLevel', ctypes.c_uint32),
    (u'baseArrayLayer', ctypes.c_uint32),
    (u'layerCount', ctypes.c_uint32),
])
ImageSubresourceRange.declare([
    (u'aspectMask', ImageAspectFlags),
    (u'baseMipLevel', ctypes.c_uint32),
    (u'levelCount', ctypes.c_uint32),
    (u'baseArrayLayer', ctypes.c_uint32),
    (u'layerCount', ctypes.c_uint32),
])
MemoryBarrier.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'srcAccessMask', AccessFlags),
    (u'dstAccessMask', AccessFlags),
])
MemoryBarrier.sType = u'MEMORY_BARRIER'
BufferMemoryBarrier.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'srcAccessMask', AccessFlags),
    (u'dstAccessMask', AccessFlags),
    (u'srcQueueFamilyIndex', ctypes.c_uint32),
    (u'dstQueueFamilyIndex', ctypes.c_uint32),
    (u'buffer', Buffer),
    (u'offset', DeviceSize),
    (u'size', DeviceSize),
])
BufferMemoryBarrier.sType = u'BUFFER_MEMORY_BARRIER'
ImageMemoryBarrier.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'srcAccessMask', AccessFlags),
    (u'dstAccessMask', AccessFlags),
    (u'oldLayout', ImageLayout),
    (u'newLayout', ImageLayout),
    (u'srcQueueFamilyIndex', ctypes.c_uint32),
    (u'dstQueueFamilyIndex', ctypes.c_uint32),
    (u'image', Image),
    (u'subresourceRange', ImageSubresourceRange),
])
ImageMemoryBarrier.sType = u'IMAGE_MEMORY_BARRIER'
ImageCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', ImageCreateFlags),
    (u'imageType', ImageType),
    (u'format', Format),
    (u'extent', Extent3D),
    (u'mipLevels', ctypes.c_uint32),
    (u'arrayLayers', ctypes.c_uint32),
    (u'samples', SampleCountFlags),
    (u'tiling', ImageTiling),
    (u'usage', ImageUsageFlags),
    (u'sharingMode', SharingMode),
    (u'queueFamilyIndexCount', ctypes.c_uint32),
    (u'pQueueFamilyIndices', vkbuilder.Pointer(ctypes.c_uint32)),
    (u'initialLayout', ImageLayout),
])
ImageCreateInfo.declare_autoarrays([
    (u'queueFamilyIndices', (u'queueFamilyIndexCount', u'pQueueFamilyIndices')),
])
ImageCreateInfo.sType = u'IMAGE_CREATE_INFO'
SubresourceLayout.declare([
    (u'offset', DeviceSize),
    (u'size', DeviceSize),
    (u'rowPitch', DeviceSize),
    (u'arrayPitch', DeviceSize),
    (u'depthPitch', DeviceSize),
])
ImageViewCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', ImageViewCreateFlags),
    (u'image', Image),
    (u'viewType', ImageViewType),
    (u'format', Format),
    (u'components', ComponentMapping),
    (u'subresourceRange', ImageSubresourceRange),
])
ImageViewCreateInfo.sType = u'IMAGE_VIEW_CREATE_INFO'
BufferCopy.declare([
    (u'srcOffset', DeviceSize),
    (u'dstOffset', DeviceSize),
    (u'size', DeviceSize),
])
SparseMemoryBind.declare([
    (u'resourceOffset', DeviceSize),
    (u'size', DeviceSize),
    (u'memory', DeviceMemory),
    (u'memoryOffset', DeviceSize),
    (u'flags', SparseMemoryBindFlags),
])
SparseImageMemoryBind.declare([
    (u'subresource', ImageSubresource),
    (u'offset', Offset3D),
    (u'extent', Extent3D),
    (u'memory', DeviceMemory),
    (u'memoryOffset', DeviceSize),
    (u'flags', SparseMemoryBindFlags),
])
SparseBufferMemoryBindInfo.declare([
    (u'buffer', Buffer),
    (u'bindCount', ctypes.c_uint32),
    (u'pBinds', vkbuilder.Pointer(SparseMemoryBind)),
])
SparseBufferMemoryBindInfo.declare_autoarrays([
    (u'binds', (u'bindCount', u'pBinds')),
])
SparseImageOpaqueMemoryBindInfo.declare([
    (u'image', Image),
    (u'bindCount', ctypes.c_uint32),
    (u'pBinds', vkbuilder.Pointer(SparseMemoryBind)),
])
SparseImageOpaqueMemoryBindInfo.declare_autoarrays([
    (u'binds', (u'bindCount', u'pBinds')),
])
SparseImageMemoryBindInfo.declare([
    (u'image', Image),
    (u'bindCount', ctypes.c_uint32),
    (u'pBinds', vkbuilder.Pointer(SparseImageMemoryBind)),
])
SparseImageMemoryBindInfo.declare_autoarrays([
    (u'binds', (u'bindCount', u'pBinds')),
])
BindSparseInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'waitSemaphoreCount', ctypes.c_uint32),
    (u'pWaitSemaphores', vkbuilder.Pointer(Semaphore)),
    (u'bufferBindCount', ctypes.c_uint32),
    (u'pBufferBinds', vkbuilder.Pointer(SparseBufferMemoryBindInfo)),
    (u'imageOpaqueBindCount', ctypes.c_uint32),
    (u'pImageOpaqueBinds', vkbuilder.Pointer(SparseImageOpaqueMemoryBindInfo)),
    (u'imageBindCount', ctypes.c_uint32),
    (u'pImageBinds', vkbuilder.Pointer(SparseImageMemoryBindInfo)),
    (u'signalSemaphoreCount', ctypes.c_uint32),
    (u'pSignalSemaphores', vkbuilder.Pointer(Semaphore)),
])
BindSparseInfo.declare_autoarrays([
    (u'waitSemaphores', (u'waitSemaphoreCount', u'pWaitSemaphores')),
    (u'bufferBinds', (u'bufferBindCount', u'pBufferBinds')),
    (u'imageOpaqueBinds', (u'imageOpaqueBindCount', u'pImageOpaqueBinds')),
    (u'imageBinds', (u'imageBindCount', u'pImageBinds')),
    (u'signalSemaphores', (u'signalSemaphoreCount', u'pSignalSemaphores')),
])
BindSparseInfo.sType = u'BIND_SPARSE_INFO'
ImageCopy.declare([
    (u'srcSubresource', ImageSubresourceLayers),
    (u'srcOffset', Offset3D),
    (u'dstSubresource', ImageSubresourceLayers),
    (u'dstOffset', Offset3D),
    (u'extent', Extent3D),
])
ImageBlit.declare([
    (u'srcSubresource', ImageSubresourceLayers),
    (u'srcOffsets', vkbuilder.Array(Offset3D, 2)),
    (u'dstSubresource', ImageSubresourceLayers),
    (u'dstOffsets', vkbuilder.Array(Offset3D, 2)),
])
BufferImageCopy.declare([
    (u'bufferOffset', DeviceSize),
    (u'bufferRowLength', ctypes.c_uint32),
    (u'bufferImageHeight', ctypes.c_uint32),
    (u'imageSubresource', ImageSubresourceLayers),
    (u'imageOffset', Offset3D),
    (u'imageExtent', Extent3D),
])
ImageResolve.declare([
    (u'srcSubresource', ImageSubresourceLayers),
    (u'srcOffset', Offset3D),
    (u'dstSubresource', ImageSubresourceLayers),
    (u'dstOffset', Offset3D),
    (u'extent', Extent3D),
])
ShaderModuleCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', ShaderModuleCreateFlags),
    (u'codeSize', ctypes.c_size_t),
    (u'pCode', vkbuilder.Pointer(ctypes.c_uint32)),
])
ShaderModuleCreateInfo.declare_autoarrays([
])
ShaderModuleCreateInfo.sType = u'SHADER_MODULE_CREATE_INFO'
DescriptorSetLayoutBinding.declare([
    (u'binding', ctypes.c_uint32),
    (u'descriptorType', DescriptorType),
    (u'descriptorCount', ctypes.c_uint32),
    (u'stageFlags', ShaderStageFlags),
    (u'pImmutableSamplers', vkbuilder.Pointer(Sampler)),
])
DescriptorSetLayoutBinding.declare_autoarrays([
    (u'immutableSamplers', (u'descriptorCount', u'pImmutableSamplers')),
])
DescriptorSetLayoutCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', DescriptorSetLayoutCreateFlags),
    (u'bindingCount', ctypes.c_uint32),
    (u'pBindings', vkbuilder.Pointer(DescriptorSetLayoutBinding)),
])
DescriptorSetLayoutCreateInfo.declare_autoarrays([
    (u'bindings', (u'bindingCount', u'pBindings')),
])
DescriptorSetLayoutCreateInfo.sType = u'DESCRIPTOR_SET_LAYOUT_CREATE_INFO'
DescriptorPoolSize.declare([
    (u'type', DescriptorType),
    (u'descriptorCount', ctypes.c_uint32),
])
DescriptorPoolCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', DescriptorPoolCreateFlags),
    (u'maxSets', ctypes.c_uint32),
    (u'poolSizeCount', ctypes.c_uint32),
    (u'pPoolSizes', vkbuilder.Pointer(DescriptorPoolSize)),
])
DescriptorPoolCreateInfo.declare_autoarrays([
    (u'poolSizes', (u'poolSizeCount', u'pPoolSizes')),
])
DescriptorPoolCreateInfo.sType = u'DESCRIPTOR_POOL_CREATE_INFO'
DescriptorSetAllocateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'descriptorPool', DescriptorPool),
    (u'descriptorSetCount', ctypes.c_uint32),
    (u'pSetLayouts', vkbuilder.Pointer(DescriptorSetLayout)),
])
DescriptorSetAllocateInfo.declare_autoarrays([
    (u'setLayouts', (u'descriptorSetCount', u'pSetLayouts')),
])
DescriptorSetAllocateInfo.sType = u'DESCRIPTOR_SET_ALLOCATE_INFO'
SpecializationMapEntry.declare([
    (u'constantID', ctypes.c_uint32),
    (u'offset', ctypes.c_uint32),
    (u'size', ctypes.c_size_t),
])
SpecializationInfo.declare([
    (u'mapEntryCount', ctypes.c_uint32),
    (u'pMapEntries', vkbuilder.Pointer(SpecializationMapEntry)),
    (u'dataSize', ctypes.c_size_t),
    (u'pData', ctypes.c_void_p),
])
SpecializationInfo.declare_autoarrays([
    (u'mapEntries', (u'mapEntryCount', u'pMapEntries')),
    (u'data', (u'dataSize', u'pData')),
])
PipelineShaderStageCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', PipelineShaderStageCreateFlags),
    (u'stage', ShaderStageFlags),
    (u'module', ShaderModule),
    (u'pName', ctypes.c_char_p),
    (u'pSpecializationInfo', vkbuilder.Pointer(SpecializationInfo)),
])
PipelineShaderStageCreateInfo.declare_aliases([
    (u'name', u'pName'),
    (u'specializationInfo', u'pSpecializationInfo'),
])
PipelineShaderStageCreateInfo.sType = u'PIPELINE_SHADER_STAGE_CREATE_INFO'
ComputePipelineCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', PipelineCreateFlags),
    (u'stage', PipelineShaderStageCreateInfo),
    (u'layout', PipelineLayout),
    (u'basePipelineHandle', Pipeline),
    (u'basePipelineIndex', ctypes.c_int32),
])
ComputePipelineCreateInfo.sType = u'COMPUTE_PIPELINE_CREATE_INFO'
VertexInputBindingDescription.declare([
    (u'binding', ctypes.c_uint32),
    (u'stride', ctypes.c_uint32),
    (u'inputRate', VertexInputRate),
])
VertexInputAttributeDescription.declare([
    (u'location', ctypes.c_uint32),
    (u'binding', ctypes.c_uint32),
    (u'format', Format),
    (u'offset', ctypes.c_uint32),
])
PipelineVertexInputStateCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', PipelineVertexInputStateCreateFlags),
    (u'vertexBindingDescriptionCount', ctypes.c_uint32),
    (u'pVertexBindingDescriptions', vkbuilder.Pointer(VertexInputBindingDescription)),
    (u'vertexAttributeDescriptionCount', ctypes.c_uint32),
    (u'pVertexAttributeDescriptions', vkbuilder.Pointer(VertexInputAttributeDescription)),
])
PipelineVertexInputStateCreateInfo.declare_autoarrays([
    (u'vertexBindingDescriptions', (u'vertexBindingDescriptionCount', u'pVertexBindingDescriptions')),
    (u'vertexAttributeDescriptions', (u'vertexAttributeDescriptionCount', u'pVertexAttributeDescriptions')),
])
PipelineVertexInputStateCreateInfo.sType = u'PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO'
PipelineInputAssemblyStateCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', PipelineInputAssemblyStateCreateFlags),
    (u'topology', PrimitiveTopology),
    (u'primitiveRestartEnable', Bool32),
])
PipelineInputAssemblyStateCreateInfo.sType = u'PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO'
PipelineTessellationStateCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', PipelineTessellationStateCreateFlags),
    (u'patchControlPoints', ctypes.c_uint32),
])
PipelineTessellationStateCreateInfo.sType = u'PIPELINE_TESSELLATION_STATE_CREATE_INFO'
PipelineViewportStateCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', PipelineViewportStateCreateFlags),
    (u'viewportCount', ctypes.c_uint32),
    (u'pViewports', vkbuilder.Pointer(Viewport)),
    (u'scissorCount', ctypes.c_uint32),
    (u'pScissors', vkbuilder.Pointer(Rect2D)),
])
PipelineViewportStateCreateInfo.declare_autoarrays([
    (u'viewports', (u'viewportCount', u'pViewports')),
    (u'scissors', (u'scissorCount', u'pScissors')),
])
PipelineViewportStateCreateInfo.sType = u'PIPELINE_VIEWPORT_STATE_CREATE_INFO'
PipelineRasterizationStateCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', PipelineRasterizationStateCreateFlags),
    (u'depthClampEnable', Bool32),
    (u'rasterizerDiscardEnable', Bool32),
    (u'polygonMode', PolygonMode),
    (u'cullMode', CullModeFlags),
    (u'frontFace', FrontFace),
    (u'depthBiasEnable', Bool32),
    (u'depthBiasConstantFactor', ctypes.c_float),
    (u'depthBiasClamp', ctypes.c_float),
    (u'depthBiasSlopeFactor', ctypes.c_float),
    (u'lineWidth', ctypes.c_float),
])
PipelineRasterizationStateCreateInfo.sType = u'PIPELINE_RASTERIZATION_STATE_CREATE_INFO'
PipelineMultisampleStateCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', PipelineMultisampleStateCreateFlags),
    (u'rasterizationSamples', SampleCountFlags),
    (u'sampleShadingEnable', Bool32),
    (u'minSampleShading', ctypes.c_float),
    (u'pSampleMask', vkbuilder.Pointer(SampleMask)),
    (u'alphaToCoverageEnable', Bool32),
    (u'alphaToOneEnable', Bool32),
])
PipelineMultisampleStateCreateInfo.declare_autoarrays([
])
PipelineMultisampleStateCreateInfo.sType = u'PIPELINE_MULTISAMPLE_STATE_CREATE_INFO'
PipelineColorBlendAttachmentState.declare([
    (u'blendEnable', Bool32),
    (u'srcColorBlendFactor', BlendFactor),
    (u'dstColorBlendFactor', BlendFactor),
    (u'colorBlendOp', BlendOp),
    (u'srcAlphaBlendFactor', BlendFactor),
    (u'dstAlphaBlendFactor', BlendFactor),
    (u'alphaBlendOp', BlendOp),
    (u'colorWriteMask', ColorComponentFlags),
])
PipelineColorBlendStateCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', PipelineColorBlendStateCreateFlags),
    (u'logicOpEnable', Bool32),
    (u'logicOp', LogicOp),
    (u'attachmentCount', ctypes.c_uint32),
    (u'pAttachments', vkbuilder.Pointer(PipelineColorBlendAttachmentState)),
    (u'blendConstants', vkbuilder.Array(ctypes.c_float, 4)),
])
PipelineColorBlendStateCreateInfo.declare_autoarrays([
    (u'attachments', (u'attachmentCount', u'pAttachments')),
])
PipelineColorBlendStateCreateInfo.sType = u'PIPELINE_COLOR_BLEND_STATE_CREATE_INFO'
PipelineDynamicStateCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', PipelineDynamicStateCreateFlags),
    (u'dynamicStateCount', ctypes.c_uint32),
    (u'pDynamicStates', vkbuilder.Pointer(DynamicState)),
])
PipelineDynamicStateCreateInfo.declare_autoarrays([
    (u'dynamicStates', (u'dynamicStateCount', u'pDynamicStates')),
])
PipelineDynamicStateCreateInfo.sType = u'PIPELINE_DYNAMIC_STATE_CREATE_INFO'
StencilOpState.declare([
    (u'failOp', StencilOp),
    (u'passOp', StencilOp),
    (u'depthFailOp', StencilOp),
    (u'compareOp', CompareOp),
    (u'compareMask', ctypes.c_uint32),
    (u'writeMask', ctypes.c_uint32),
    (u'reference', ctypes.c_uint32),
])
PipelineDepthStencilStateCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', PipelineDepthStencilStateCreateFlags),
    (u'depthTestEnable', Bool32),
    (u'depthWriteEnable', Bool32),
    (u'depthCompareOp', CompareOp),
    (u'depthBoundsTestEnable', Bool32),
    (u'stencilTestEnable', Bool32),
    (u'front', StencilOpState),
    (u'back', StencilOpState),
    (u'minDepthBounds', ctypes.c_float),
    (u'maxDepthBounds', ctypes.c_float),
])
PipelineDepthStencilStateCreateInfo.sType = u'PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO'
GraphicsPipelineCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', PipelineCreateFlags),
    (u'stageCount', ctypes.c_uint32),
    (u'pStages', vkbuilder.Pointer(PipelineShaderStageCreateInfo)),
    (u'pVertexInputState', vkbuilder.Pointer(PipelineVertexInputStateCreateInfo)),
    (u'pInputAssemblyState', vkbuilder.Pointer(PipelineInputAssemblyStateCreateInfo)),
    (u'pTessellationState', vkbuilder.Pointer(PipelineTessellationStateCreateInfo)),
    (u'pViewportState', vkbuilder.Pointer(PipelineViewportStateCreateInfo)),
    (u'pRasterizationState', vkbuilder.Pointer(PipelineRasterizationStateCreateInfo)),
    (u'pMultisampleState', vkbuilder.Pointer(PipelineMultisampleStateCreateInfo)),
    (u'pDepthStencilState', vkbuilder.Pointer(PipelineDepthStencilStateCreateInfo)),
    (u'pColorBlendState', vkbuilder.Pointer(PipelineColorBlendStateCreateInfo)),
    (u'pDynamicState', vkbuilder.Pointer(PipelineDynamicStateCreateInfo)),
    (u'layout', PipelineLayout),
    (u'renderPass', RenderPass),
    (u'subpass', ctypes.c_uint32),
    (u'basePipelineHandle', Pipeline),
    (u'basePipelineIndex', ctypes.c_int32),
])
GraphicsPipelineCreateInfo.declare_autoarrays([
    (u'stages', (u'stageCount', u'pStages')),
])
GraphicsPipelineCreateInfo.declare_aliases([
    (u'vertexInputState', u'pVertexInputState'),
    (u'inputAssemblyState', u'pInputAssemblyState'),
    (u'tessellationState', u'pTessellationState'),
    (u'viewportState', u'pViewportState'),
    (u'rasterizationState', u'pRasterizationState'),
    (u'multisampleState', u'pMultisampleState'),
    (u'depthStencilState', u'pDepthStencilState'),
    (u'colorBlendState', u'pColorBlendState'),
    (u'dynamicState', u'pDynamicState'),
])
GraphicsPipelineCreateInfo.sType = u'GRAPHICS_PIPELINE_CREATE_INFO'
PipelineCacheCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', PipelineCacheCreateFlags),
    (u'initialDataSize', ctypes.c_size_t),
    (u'pInitialData', ctypes.c_void_p),
])
PipelineCacheCreateInfo.declare_autoarrays([
    (u'initialData', (u'initialDataSize', u'pInitialData')),
])
PipelineCacheCreateInfo.sType = u'PIPELINE_CACHE_CREATE_INFO'
PushConstantRange.declare([
    (u'stageFlags', ShaderStageFlags),
    (u'offset', ctypes.c_uint32),
    (u'size', ctypes.c_uint32),
])
PipelineLayoutCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', PipelineLayoutCreateFlags),
    (u'setLayoutCount', ctypes.c_uint32),
    (u'pSetLayouts', vkbuilder.Pointer(DescriptorSetLayout)),
    (u'pushConstantRangeCount', ctypes.c_uint32),
    (u'pPushConstantRanges', vkbuilder.Pointer(PushConstantRange)),
])
PipelineLayoutCreateInfo.declare_autoarrays([
    (u'setLayouts', (u'setLayoutCount', u'pSetLayouts')),
    (u'pushConstantRanges', (u'pushConstantRangeCount', u'pPushConstantRanges')),
])
PipelineLayoutCreateInfo.sType = u'PIPELINE_LAYOUT_CREATE_INFO'
SamplerCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', SamplerCreateFlags),
    (u'magFilter', Filter),
    (u'minFilter', Filter),
    (u'mipmapMode', SamplerMipmapMode),
    (u'addressModeU', SamplerAddressMode),
    (u'addressModeV', SamplerAddressMode),
    (u'addressModeW', SamplerAddressMode),
    (u'mipLodBias', ctypes.c_float),
    (u'anisotropyEnable', Bool32),
    (u'maxAnisotropy', ctypes.c_float),
    (u'compareEnable', Bool32),
    (u'compareOp', CompareOp),
    (u'minLod', ctypes.c_float),
    (u'maxLod', ctypes.c_float),
    (u'borderColor', BorderColor),
    (u'unnormalizedCoordinates', Bool32),
])
SamplerCreateInfo.sType = u'SAMPLER_CREATE_INFO'
CommandPoolCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', CommandPoolCreateFlags),
    (u'queueFamilyIndex', ctypes.c_uint32),
])
CommandPoolCreateInfo.sType = u'COMMAND_POOL_CREATE_INFO'
CommandBufferAllocateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'commandPool', CommandPool),
    (u'level', CommandBufferLevel),
    (u'commandBufferCount', ctypes.c_uint32),
])
CommandBufferAllocateInfo.sType = u'COMMAND_BUFFER_ALLOCATE_INFO'
CommandBufferInheritanceInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'renderPass', RenderPass),
    (u'subpass', ctypes.c_uint32),
    (u'framebuffer', Framebuffer),
    (u'occlusionQueryEnable', Bool32),
    (u'queryFlags', QueryControlFlags),
    (u'pipelineStatistics', QueryPipelineStatisticFlags),
])
CommandBufferInheritanceInfo.sType = u'COMMAND_BUFFER_INHERITANCE_INFO'
CommandBufferBeginInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', CommandBufferUsageFlags),
    (u'pInheritanceInfo', vkbuilder.Pointer(CommandBufferInheritanceInfo)),
])
CommandBufferBeginInfo.declare_aliases([
    (u'inheritanceInfo', u'pInheritanceInfo'),
])
CommandBufferBeginInfo.sType = u'COMMAND_BUFFER_BEGIN_INFO'
RenderPassBeginInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'renderPass', RenderPass),
    (u'framebuffer', Framebuffer),
    (u'renderArea', Rect2D),
    (u'clearValueCount', ctypes.c_uint32),
    (u'pClearValues', vkbuilder.Pointer(ClearValue)),
])
RenderPassBeginInfo.declare_autoarrays([
    (u'clearValues', (u'clearValueCount', u'pClearValues')),
])
RenderPassBeginInfo.sType = u'RENDER_PASS_BEGIN_INFO'
ClearColorValue.declare([
    (u'float32', vkbuilder.Array(ctypes.c_float, 4)),
    (u'int32', vkbuilder.Array(ctypes.c_int32, 4)),
    (u'uint32', vkbuilder.Array(ctypes.c_uint32, 4)),
])
ClearDepthStencilValue.declare([
    (u'depth', ctypes.c_float),
    (u'stencil', ctypes.c_uint32),
])
ClearValue.declare([
    (u'color', ClearColorValue),
    (u'depthStencil', ClearDepthStencilValue),
])
ClearAttachment.declare([
    (u'aspectMask', ImageAspectFlags),
    (u'colorAttachment', ctypes.c_uint32),
    (u'clearValue', ClearValue),
])
AttachmentDescription.declare([
    (u'flags', AttachmentDescriptionFlags),
    (u'format', Format),
    (u'samples', SampleCountFlags),
    (u'loadOp', AttachmentLoadOp),
    (u'storeOp', AttachmentStoreOp),
    (u'stencilLoadOp', AttachmentLoadOp),
    (u'stencilStoreOp', AttachmentStoreOp),
    (u'initialLayout', ImageLayout),
    (u'finalLayout', ImageLayout),
])
AttachmentReference.declare([
    (u'attachment', ctypes.c_uint32),
    (u'layout', ImageLayout),
])
SubpassDescription.declare([
    (u'flags', SubpassDescriptionFlags),
    (u'pipelineBindPoint', PipelineBindPoint),
    (u'inputAttachmentCount', ctypes.c_uint32),
    (u'pInputAttachments', vkbuilder.Pointer(AttachmentReference)),
    (u'colorAttachmentCount', ctypes.c_uint32),
    (u'pColorAttachments', vkbuilder.Pointer(AttachmentReference)),
    (u'pResolveAttachments', vkbuilder.Pointer(AttachmentReference)),
    (u'pDepthStencilAttachment', vkbuilder.Pointer(AttachmentReference)),
    (u'preserveAttachmentCount', ctypes.c_uint32),
    (u'pPreserveAttachments', vkbuilder.Pointer(ctypes.c_uint32)),
])
SubpassDescription.declare_autoarrays([
    (u'inputAttachments', (u'inputAttachmentCount', u'pInputAttachments')),
    (u'colorAttachments', (u'colorAttachmentCount', u'pColorAttachments')),
    (u'resolveAttachments', (u'colorAttachmentCount', u'pResolveAttachments')),
    (u'preserveAttachments', (u'preserveAttachmentCount', u'pPreserveAttachments')),
])
SubpassDescription.declare_aliases([
    (u'depthStencilAttachment', u'pDepthStencilAttachment'),
])
SubpassDependency.declare([
    (u'srcSubpass', ctypes.c_uint32),
    (u'dstSubpass', ctypes.c_uint32),
    (u'srcStageMask', PipelineStageFlags),
    (u'dstStageMask', PipelineStageFlags),
    (u'srcAccessMask', AccessFlags),
    (u'dstAccessMask', AccessFlags),
    (u'dependencyFlags', DependencyFlags),
])
RenderPassCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', RenderPassCreateFlags),
    (u'attachmentCount', ctypes.c_uint32),
    (u'pAttachments', vkbuilder.Pointer(AttachmentDescription)),
    (u'subpassCount', ctypes.c_uint32),
    (u'pSubpasses', vkbuilder.Pointer(SubpassDescription)),
    (u'dependencyCount', ctypes.c_uint32),
    (u'pDependencies', vkbuilder.Pointer(SubpassDependency)),
])
RenderPassCreateInfo.declare_autoarrays([
    (u'attachments', (u'attachmentCount', u'pAttachments')),
    (u'subpasses', (u'subpassCount', u'pSubpasses')),
    (u'dependencies', (u'dependencyCount', u'pDependencies')),
])
RenderPassCreateInfo.sType = u'RENDER_PASS_CREATE_INFO'
EventCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', EventCreateFlags),
])
EventCreateInfo.sType = u'EVENT_CREATE_INFO'
FenceCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', FenceCreateFlags),
])
FenceCreateInfo.sType = u'FENCE_CREATE_INFO'
PhysicalDeviceFeatures.declare([
    (u'robustBufferAccess', Bool32),
    (u'fullDrawIndexUint32', Bool32),
    (u'imageCubeArray', Bool32),
    (u'independentBlend', Bool32),
    (u'geometryShader', Bool32),
    (u'tessellationShader', Bool32),
    (u'sampleRateShading', Bool32),
    (u'dualSrcBlend', Bool32),
    (u'logicOp', Bool32),
    (u'multiDrawIndirect', Bool32),
    (u'drawIndirectFirstInstance', Bool32),
    (u'depthClamp', Bool32),
    (u'depthBiasClamp', Bool32),
    (u'fillModeNonSolid', Bool32),
    (u'depthBounds', Bool32),
    (u'wideLines', Bool32),
    (u'largePoints', Bool32),
    (u'alphaToOne', Bool32),
    (u'multiViewport', Bool32),
    (u'samplerAnisotropy', Bool32),
    (u'textureCompressionETC2', Bool32),
    (u'textureCompressionASTC_LDR', Bool32),
    (u'textureCompressionBC', Bool32),
    (u'occlusionQueryPrecise', Bool32),
    (u'pipelineStatisticsQuery', Bool32),
    (u'vertexPipelineStoresAndAtomics', Bool32),
    (u'fragmentStoresAndAtomics', Bool32),
    (u'shaderTessellationAndGeometryPointSize', Bool32),
    (u'shaderImageGatherExtended', Bool32),
    (u'shaderStorageImageExtendedFormats', Bool32),
    (u'shaderStorageImageMultisample', Bool32),
    (u'shaderStorageImageReadWithoutFormat', Bool32),
    (u'shaderStorageImageWriteWithoutFormat', Bool32),
    (u'shaderUniformBufferArrayDynamicIndexing', Bool32),
    (u'shaderSampledImageArrayDynamicIndexing', Bool32),
    (u'shaderStorageBufferArrayDynamicIndexing', Bool32),
    (u'shaderStorageImageArrayDynamicIndexing', Bool32),
    (u'shaderClipDistance', Bool32),
    (u'shaderCullDistance', Bool32),
    (u'shaderFloat64', Bool32),
    (u'shaderInt64', Bool32),
    (u'shaderInt16', Bool32),
    (u'shaderResourceResidency', Bool32),
    (u'shaderResourceMinLod', Bool32),
    (u'sparseBinding', Bool32),
    (u'sparseResidencyBuffer', Bool32),
    (u'sparseResidencyImage2D', Bool32),
    (u'sparseResidencyImage3D', Bool32),
    (u'sparseResidency2Samples', Bool32),
    (u'sparseResidency4Samples', Bool32),
    (u'sparseResidency8Samples', Bool32),
    (u'sparseResidency16Samples', Bool32),
    (u'sparseResidencyAliased', Bool32),
    (u'variableMultisampleRate', Bool32),
    (u'inheritedQueries', Bool32),
])
PhysicalDeviceSparseProperties.declare([
    (u'residencyStandard2DBlockShape', Bool32),
    (u'residencyStandard2DMultisampleBlockShape', Bool32),
    (u'residencyStandard3DBlockShape', Bool32),
    (u'residencyAlignedMipSize', Bool32),
    (u'residencyNonResidentStrict', Bool32),
])
PhysicalDeviceLimits.declare([
    (u'maxImageDimension1D', ctypes.c_uint32),
    (u'maxImageDimension2D', ctypes.c_uint32),
    (u'maxImageDimension3D', ctypes.c_uint32),
    (u'maxImageDimensionCube', ctypes.c_uint32),
    (u'maxImageArrayLayers', ctypes.c_uint32),
    (u'maxTexelBufferElements', ctypes.c_uint32),
    (u'maxUniformBufferRange', ctypes.c_uint32),
    (u'maxStorageBufferRange', ctypes.c_uint32),
    (u'maxPushConstantsSize', ctypes.c_uint32),
    (u'maxMemoryAllocationCount', ctypes.c_uint32),
    (u'maxSamplerAllocationCount', ctypes.c_uint32),
    (u'bufferImageGranularity', DeviceSize),
    (u'sparseAddressSpaceSize', DeviceSize),
    (u'maxBoundDescriptorSets', ctypes.c_uint32),
    (u'maxPerStageDescriptorSamplers', ctypes.c_uint32),
    (u'maxPerStageDescriptorUniformBuffers', ctypes.c_uint32),
    (u'maxPerStageDescriptorStorageBuffers', ctypes.c_uint32),
    (u'maxPerStageDescriptorSampledImages', ctypes.c_uint32),
    (u'maxPerStageDescriptorStorageImages', ctypes.c_uint32),
    (u'maxPerStageDescriptorInputAttachments', ctypes.c_uint32),
    (u'maxPerStageResources', ctypes.c_uint32),
    (u'maxDescriptorSetSamplers', ctypes.c_uint32),
    (u'maxDescriptorSetUniformBuffers', ctypes.c_uint32),
    (u'maxDescriptorSetUniformBuffersDynamic', ctypes.c_uint32),
    (u'maxDescriptorSetStorageBuffers', ctypes.c_uint32),
    (u'maxDescriptorSetStorageBuffersDynamic', ctypes.c_uint32),
    (u'maxDescriptorSetSampledImages', ctypes.c_uint32),
    (u'maxDescriptorSetStorageImages', ctypes.c_uint32),
    (u'maxDescriptorSetInputAttachments', ctypes.c_uint32),
    (u'maxVertexInputAttributes', ctypes.c_uint32),
    (u'maxVertexInputBindings', ctypes.c_uint32),
    (u'maxVertexInputAttributeOffset', ctypes.c_uint32),
    (u'maxVertexInputBindingStride', ctypes.c_uint32),
    (u'maxVertexOutputComponents', ctypes.c_uint32),
    (u'maxTessellationGenerationLevel', ctypes.c_uint32),
    (u'maxTessellationPatchSize', ctypes.c_uint32),
    (u'maxTessellationControlPerVertexInputComponents', ctypes.c_uint32),
    (u'maxTessellationControlPerVertexOutputComponents', ctypes.c_uint32),
    (u'maxTessellationControlPerPatchOutputComponents', ctypes.c_uint32),
    (u'maxTessellationControlTotalOutputComponents', ctypes.c_uint32),
    (u'maxTessellationEvaluationInputComponents', ctypes.c_uint32),
    (u'maxTessellationEvaluationOutputComponents', ctypes.c_uint32),
    (u'maxGeometryShaderInvocations', ctypes.c_uint32),
    (u'maxGeometryInputComponents', ctypes.c_uint32),
    (u'maxGeometryOutputComponents', ctypes.c_uint32),
    (u'maxGeometryOutputVertices', ctypes.c_uint32),
    (u'maxGeometryTotalOutputComponents', ctypes.c_uint32),
    (u'maxFragmentInputComponents', ctypes.c_uint32),
    (u'maxFragmentOutputAttachments', ctypes.c_uint32),
    (u'maxFragmentDualSrcAttachments', ctypes.c_uint32),
    (u'maxFragmentCombinedOutputResources', ctypes.c_uint32),
    (u'maxComputeSharedMemorySize', ctypes.c_uint32),
    (u'maxComputeWorkGroupCount', vkbuilder.Array(ctypes.c_uint32, 3)),
    (u'maxComputeWorkGroupInvocations', ctypes.c_uint32),
    (u'maxComputeWorkGroupSize', vkbuilder.Array(ctypes.c_uint32, 3)),
    (u'subPixelPrecisionBits', ctypes.c_uint32),
    (u'subTexelPrecisionBits', ctypes.c_uint32),
    (u'mipmapPrecisionBits', ctypes.c_uint32),
    (u'maxDrawIndexedIndexValue', ctypes.c_uint32),
    (u'maxDrawIndirectCount', ctypes.c_uint32),
    (u'maxSamplerLodBias', ctypes.c_float),
    (u'maxSamplerAnisotropy', ctypes.c_float),
    (u'maxViewports', ctypes.c_uint32),
    (u'maxViewportDimensions', vkbuilder.Array(ctypes.c_uint32, 2)),
    (u'viewportBoundsRange', vkbuilder.Array(ctypes.c_float, 2)),
    (u'viewportSubPixelBits', ctypes.c_uint32),
    (u'minMemoryMapAlignment', ctypes.c_size_t),
    (u'minTexelBufferOffsetAlignment', DeviceSize),
    (u'minUniformBufferOffsetAlignment', DeviceSize),
    (u'minStorageBufferOffsetAlignment', DeviceSize),
    (u'minTexelOffset', ctypes.c_int32),
    (u'maxTexelOffset', ctypes.c_uint32),
    (u'minTexelGatherOffset', ctypes.c_int32),
    (u'maxTexelGatherOffset', ctypes.c_uint32),
    (u'minInterpolationOffset', ctypes.c_float),
    (u'maxInterpolationOffset', ctypes.c_float),
    (u'subPixelInterpolationOffsetBits', ctypes.c_uint32),
    (u'maxFramebufferWidth', ctypes.c_uint32),
    (u'maxFramebufferHeight', ctypes.c_uint32),
    (u'maxFramebufferLayers', ctypes.c_uint32),
    (u'framebufferColorSampleCounts', SampleCountFlags),
    (u'framebufferDepthSampleCounts', SampleCountFlags),
    (u'framebufferStencilSampleCounts', SampleCountFlags),
    (u'framebufferNoAttachmentsSampleCounts', SampleCountFlags),
    (u'maxColorAttachments', ctypes.c_uint32),
    (u'sampledImageColorSampleCounts', SampleCountFlags),
    (u'sampledImageIntegerSampleCounts', SampleCountFlags),
    (u'sampledImageDepthSampleCounts', SampleCountFlags),
    (u'sampledImageStencilSampleCounts', SampleCountFlags),
    (u'storageImageSampleCounts', SampleCountFlags),
    (u'maxSampleMaskWords', ctypes.c_uint32),
    (u'timestampComputeAndGraphics', Bool32),
    (u'timestampPeriod', ctypes.c_float),
    (u'maxClipDistances', ctypes.c_uint32),
    (u'maxCullDistances', ctypes.c_uint32),
    (u'maxCombinedClipAndCullDistances', ctypes.c_uint32),
    (u'discreteQueuePriorities', ctypes.c_uint32),
    (u'pointSizeRange', vkbuilder.Array(ctypes.c_float, 2)),
    (u'lineWidthRange', vkbuilder.Array(ctypes.c_float, 2)),
    (u'pointSizeGranularity', ctypes.c_float),
    (u'lineWidthGranularity', ctypes.c_float),
    (u'strictLines', Bool32),
    (u'standardSampleLocations', Bool32),
    (u'optimalBufferCopyOffsetAlignment', DeviceSize),
    (u'optimalBufferCopyRowPitchAlignment', DeviceSize),
    (u'nonCoherentAtomSize', DeviceSize),
])
SemaphoreCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', SemaphoreCreateFlags),
])
SemaphoreCreateInfo.sType = u'SEMAPHORE_CREATE_INFO'
QueryPoolCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', QueryPoolCreateFlags),
    (u'queryType', QueryType),
    (u'queryCount', ctypes.c_uint32),
    (u'pipelineStatistics', QueryPipelineStatisticFlags),
])
QueryPoolCreateInfo.sType = u'QUERY_POOL_CREATE_INFO'
FramebufferCreateInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', FramebufferCreateFlags),
    (u'renderPass', RenderPass),
    (u'attachmentCount', ctypes.c_uint32),
    (u'pAttachments', vkbuilder.Pointer(ImageView)),
    (u'width', ctypes.c_uint32),
    (u'height', ctypes.c_uint32),
    (u'layers', ctypes.c_uint32),
])
FramebufferCreateInfo.declare_autoarrays([
    (u'attachments', (u'attachmentCount', u'pAttachments')),
])
FramebufferCreateInfo.sType = u'FRAMEBUFFER_CREATE_INFO'
DrawIndirectCommand.declare([
    (u'vertexCount', ctypes.c_uint32),
    (u'instanceCount', ctypes.c_uint32),
    (u'firstVertex', ctypes.c_uint32),
    (u'firstInstance', ctypes.c_uint32),
])
DrawIndexedIndirectCommand.declare([
    (u'indexCount', ctypes.c_uint32),
    (u'instanceCount', ctypes.c_uint32),
    (u'firstIndex', ctypes.c_uint32),
    (u'vertexOffset', ctypes.c_int32),
    (u'firstInstance', ctypes.c_uint32),
])
DispatchIndirectCommand.declare([
    (u'x', ctypes.c_uint32),
    (u'y', ctypes.c_uint32),
    (u'z', ctypes.c_uint32),
])
SubmitInfo.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'waitSemaphoreCount', ctypes.c_uint32),
    (u'pWaitSemaphores', vkbuilder.Pointer(Semaphore)),
    (u'pWaitDstStageMask', vkbuilder.Pointer(PipelineStageFlags)),
    (u'commandBufferCount', ctypes.c_uint32),
    (u'pCommandBuffers', vkbuilder.Pointer(CommandBuffer)),
    (u'signalSemaphoreCount', ctypes.c_uint32),
    (u'pSignalSemaphores', vkbuilder.Pointer(Semaphore)),
])
SubmitInfo.declare_autoarrays([
    (u'waitSemaphores', (u'waitSemaphoreCount', u'pWaitSemaphores')),
    (u'waitDstStageMask', (u'waitSemaphoreCount', u'pWaitDstStageMask')),
    (u'commandBuffers', (u'commandBufferCount', u'pCommandBuffers')),
    (u'signalSemaphores', (u'signalSemaphoreCount', u'pSignalSemaphores')),
])
SubmitInfo.sType = u'SUBMIT_INFO'
DisplayPropertiesKHR.declare([
    (u'display', DisplayKHR),
    (u'displayName', ctypes.c_char_p),
    (u'physicalDimensions', Extent2D),
    (u'physicalResolution', Extent2D),
    (u'supportedTransforms', SurfaceTransformFlagsKHR),
    (u'planeReorderPossible', Bool32),
    (u'persistentContent', Bool32),
])
DisplayPlanePropertiesKHR.declare([
    (u'currentDisplay', DisplayKHR),
    (u'currentStackIndex', ctypes.c_uint32),
])
DisplayModeParametersKHR.declare([
    (u'visibleRegion', Extent2D),
    (u'refreshRate', ctypes.c_uint32),
])
DisplayModePropertiesKHR.declare([
    (u'displayMode', DisplayModeKHR),
    (u'parameters', DisplayModeParametersKHR),
])
DisplayModeCreateInfoKHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', DisplayModeCreateFlagsKHR),
    (u'parameters', DisplayModeParametersKHR),
])
DisplayModeCreateInfoKHR.sType = u'DISPLAY_MODE_CREATE_INFO_KHR'
DisplayPlaneCapabilitiesKHR.declare([
    (u'supportedAlpha', DisplayPlaneAlphaFlagsKHR),
    (u'minSrcPosition', Offset2D),
    (u'maxSrcPosition', Offset2D),
    (u'minSrcExtent', Extent2D),
    (u'maxSrcExtent', Extent2D),
    (u'minDstPosition', Offset2D),
    (u'maxDstPosition', Offset2D),
    (u'minDstExtent', Extent2D),
    (u'maxDstExtent', Extent2D),
])
DisplaySurfaceCreateInfoKHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', DisplaySurfaceCreateFlagsKHR),
    (u'displayMode', DisplayModeKHR),
    (u'planeIndex', ctypes.c_uint32),
    (u'planeStackIndex', ctypes.c_uint32),
    (u'transform', SurfaceTransformFlagsKHR),
    (u'globalAlpha', ctypes.c_float),
    (u'alphaMode', DisplayPlaneAlphaFlagsKHR),
    (u'imageExtent', Extent2D),
])
DisplaySurfaceCreateInfoKHR.sType = u'DISPLAY_SURFACE_CREATE_INFO_KHR'
DisplayPresentInfoKHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'srcRect', Rect2D),
    (u'dstRect', Rect2D),
    (u'persistent', Bool32),
])
DisplayPresentInfoKHR.sType = u'DISPLAY_PRESENT_INFO_KHR'
SurfaceCapabilitiesKHR.declare([
    (u'minImageCount', ctypes.c_uint32),
    (u'maxImageCount', ctypes.c_uint32),
    (u'currentExtent', Extent2D),
    (u'minImageExtent', Extent2D),
    (u'maxImageExtent', Extent2D),
    (u'maxImageArrayLayers', ctypes.c_uint32),
    (u'supportedTransforms', SurfaceTransformFlagsKHR),
    (u'currentTransform', SurfaceTransformFlagsKHR),
    (u'supportedCompositeAlpha', CompositeAlphaFlagsKHR),
    (u'supportedUsageFlags', ImageUsageFlags),
])
AndroidSurfaceCreateInfoKHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', AndroidSurfaceCreateFlagsKHR),
    (u'window', vkbuilder.Pointer(ctypes.c_void_p)),
])
AndroidSurfaceCreateInfoKHR.sType = u'ANDROID_SURFACE_CREATE_INFO_KHR'
MirSurfaceCreateInfoKHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', MirSurfaceCreateFlagsKHR),
    (u'connection', vkbuilder.Pointer(ctypes.c_void_p)),
    (u'mirSurface', vkbuilder.Pointer(ctypes.c_void_p)),
])
MirSurfaceCreateInfoKHR.sType = u'MIR_SURFACE_CREATE_INFO_KHR'
ViSurfaceCreateInfoNN.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', ViSurfaceCreateFlagsNN),
    (u'window', ctypes.c_void_p),
])
ViSurfaceCreateInfoNN.sType = u'VI_SURFACE_CREATE_INFO_NN'
WaylandSurfaceCreateInfoKHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', WaylandSurfaceCreateFlagsKHR),
    (u'display', ctypes.c_void_p),
    (u'surface', ctypes.c_void_p),
])
WaylandSurfaceCreateInfoKHR.sType = u'WAYLAND_SURFACE_CREATE_INFO_KHR'
Win32SurfaceCreateInfoKHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', Win32SurfaceCreateFlagsKHR),
    (u'hinstance', ctypes.c_void_p),
    (u'hwnd', ctypes.c_void_p),
])
Win32SurfaceCreateInfoKHR.sType = u'WIN_32_SURFACE_CREATE_INFO_KHR'
XlibSurfaceCreateInfoKHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', XlibSurfaceCreateFlagsKHR),
    (u'dpy', vkbuilder.Pointer(ctypes.c_void_p)),
    (u'window', ctypes.c_void_p),
])
XlibSurfaceCreateInfoKHR.sType = u'XLIB_SURFACE_CREATE_INFO_KHR'
XcbSurfaceCreateInfoKHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', XcbSurfaceCreateFlagsKHR),
    (u'connection', ctypes.c_void_p),
    (u'window', ctypes.c_void_p),
])
XcbSurfaceCreateInfoKHR.sType = u'XCB_SURFACE_CREATE_INFO_KHR'
SurfaceFormatKHR.declare([
    (u'format', Format),
    (u'colorSpace', ColorSpaceKHR),
])
SwapchainCreateInfoKHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', SwapchainCreateFlagsKHR),
    (u'surface', SurfaceKHR),
    (u'minImageCount', ctypes.c_uint32),
    (u'imageFormat', Format),
    (u'imageColorSpace', ColorSpaceKHR),
    (u'imageExtent', Extent2D),
    (u'imageArrayLayers', ctypes.c_uint32),
    (u'imageUsage', ImageUsageFlags),
    (u'imageSharingMode', SharingMode),
    (u'queueFamilyIndexCount', ctypes.c_uint32),
    (u'pQueueFamilyIndices', vkbuilder.Pointer(ctypes.c_uint32)),
    (u'preTransform', SurfaceTransformFlagsKHR),
    (u'compositeAlpha', CompositeAlphaFlagsKHR),
    (u'presentMode', PresentModeKHR),
    (u'clipped', Bool32),
    (u'oldSwapchain', SwapchainKHR),
])
SwapchainCreateInfoKHR.declare_autoarrays([
    (u'queueFamilyIndices', (u'queueFamilyIndexCount', u'pQueueFamilyIndices')),
])
SwapchainCreateInfoKHR.sType = u'SWAPCHAIN_CREATE_INFO_KHR'
PresentInfoKHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'waitSemaphoreCount', ctypes.c_uint32),
    (u'pWaitSemaphores', vkbuilder.Pointer(Semaphore)),
    (u'swapchainCount', ctypes.c_uint32),
    (u'pSwapchains', vkbuilder.Pointer(SwapchainKHR)),
    (u'pImageIndices', vkbuilder.Pointer(ctypes.c_uint32)),
    (u'pResults', vkbuilder.Pointer(Result)),
])
PresentInfoKHR.declare_autoarrays([
    (u'waitSemaphores', (u'waitSemaphoreCount', u'pWaitSemaphores')),
    (u'swapchains', (u'swapchainCount', u'pSwapchains')),
    (u'imageIndices', (u'swapchainCount', u'pImageIndices')),
    (u'results', (u'swapchainCount', u'pResults')),
])
PresentInfoKHR.sType = u'PRESENT_INFO_KHR'
DebugReportCallbackCreateInfoEXT.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', DebugReportFlagsEXT),
    (u'pfnCallback', PFN_DebugReportCallbackEXT),
    (u'pUserData', ctypes.c_void_p),
])
DebugReportCallbackCreateInfoEXT.declare_aliases([
    (u'userData', u'pUserData'),
])
DebugReportCallbackCreateInfoEXT.sType = u'DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT'
ValidationFlagsEXT.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'disabledValidationCheckCount', ctypes.c_uint32),
    (u'pDisabledValidationChecks', vkbuilder.Pointer(ValidationCheckEXT)),
])
ValidationFlagsEXT.declare_autoarrays([
    (u'disabledValidationChecks', (u'disabledValidationCheckCount', u'pDisabledValidationChecks')),
])
ValidationFlagsEXT.sType = u'VALIDATION_FLAGS_EXT'
PipelineRasterizationStateRasterizationOrderAMD.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'rasterizationOrder', RasterizationOrderAMD),
])
PipelineRasterizationStateRasterizationOrderAMD.sType = u'PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD'
DebugMarkerObjectNameInfoEXT.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'objectType', DebugReportObjectTypeEXT),
    (u'object', ctypes.c_uint64),
    (u'pObjectName', ctypes.c_char_p),
])
DebugMarkerObjectNameInfoEXT.declare_aliases([
    (u'objectName', u'pObjectName'),
])
DebugMarkerObjectNameInfoEXT.sType = u'DEBUG_MARKER_OBJECT_NAME_INFO_EXT'
DebugMarkerObjectTagInfoEXT.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'objectType', DebugReportObjectTypeEXT),
    (u'object', ctypes.c_uint64),
    (u'tagName', ctypes.c_uint64),
    (u'tagSize', ctypes.c_size_t),
    (u'pTag', ctypes.c_void_p),
])
DebugMarkerObjectTagInfoEXT.declare_autoarrays([
    (u'tag', (u'tagSize', u'pTag')),
])
DebugMarkerObjectTagInfoEXT.sType = u'DEBUG_MARKER_OBJECT_TAG_INFO_EXT'
DebugMarkerMarkerInfoEXT.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'pMarkerName', ctypes.c_char_p),
    (u'color', vkbuilder.Array(ctypes.c_float, 4)),
])
DebugMarkerMarkerInfoEXT.declare_aliases([
    (u'markerName', u'pMarkerName'),
])
DebugMarkerMarkerInfoEXT.sType = u'DEBUG_MARKER_MARKER_INFO_EXT'
DedicatedAllocationImageCreateInfoNV.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'dedicatedAllocation', Bool32),
])
DedicatedAllocationImageCreateInfoNV.sType = u'DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV'
DedicatedAllocationBufferCreateInfoNV.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'dedicatedAllocation', Bool32),
])
DedicatedAllocationBufferCreateInfoNV.sType = u'DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV'
DedicatedAllocationMemoryAllocateInfoNV.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'image', Image),
    (u'buffer', Buffer),
])
DedicatedAllocationMemoryAllocateInfoNV.sType = u'DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV'
ExternalImageFormatPropertiesNV.declare([
    (u'imageFormatProperties', ImageFormatProperties),
    (u'externalMemoryFeatures', ExternalMemoryFeatureFlagsNV),
    (u'exportFromImportedHandleTypes', ExternalMemoryHandleTypeFlagsNV),
    (u'compatibleHandleTypes', ExternalMemoryHandleTypeFlagsNV),
])
ExternalMemoryImageCreateInfoNV.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'handleTypes', ExternalMemoryHandleTypeFlagsNV),
])
ExternalMemoryImageCreateInfoNV.sType = u'EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV'
ExportMemoryAllocateInfoNV.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'handleTypes', ExternalMemoryHandleTypeFlagsNV),
])
ExportMemoryAllocateInfoNV.sType = u'EXPORT_MEMORY_ALLOCATE_INFO_NV'
ImportMemoryWin32HandleInfoNV.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'handleType', ExternalMemoryHandleTypeFlagsNV),
    (u'handle', ctypes.c_void_p),
])
ImportMemoryWin32HandleInfoNV.sType = u'IMPORT_MEMORY_WIN_32_HANDLE_INFO_NV'
ExportMemoryWin32HandleInfoNV.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'pAttributes', vkbuilder.Pointer(ctypes.c_void_p)),
    (u'dwAccess', ctypes.c_uint32),
])
ExportMemoryWin32HandleInfoNV.declare_aliases([
    (u'attributes', u'pAttributes'),
])
ExportMemoryWin32HandleInfoNV.sType = u'EXPORT_MEMORY_WIN_32_HANDLE_INFO_NV'
Win32KeyedMutexAcquireReleaseInfoNV.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'acquireCount', ctypes.c_uint32),
    (u'pAcquireSyncs', vkbuilder.Pointer(DeviceMemory)),
    (u'pAcquireKeys', vkbuilder.Pointer(ctypes.c_uint64)),
    (u'pAcquireTimeoutMilliseconds', vkbuilder.Pointer(ctypes.c_uint32)),
    (u'releaseCount', ctypes.c_uint32),
    (u'pReleaseSyncs', vkbuilder.Pointer(DeviceMemory)),
    (u'pReleaseKeys', vkbuilder.Pointer(ctypes.c_uint64)),
])
Win32KeyedMutexAcquireReleaseInfoNV.declare_autoarrays([
    (u'acquireSyncs', (u'acquireCount', u'pAcquireSyncs')),
    (u'acquireKeys', (u'acquireCount', u'pAcquireKeys')),
    (u'acquireTimeoutMilliseconds', (u'acquireCount', u'pAcquireTimeoutMilliseconds')),
    (u'releaseSyncs', (u'releaseCount', u'pReleaseSyncs')),
    (u'releaseKeys', (u'releaseCount', u'pReleaseKeys')),
])
Win32KeyedMutexAcquireReleaseInfoNV.sType = u'WIN_32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV'
DeviceGeneratedCommandsFeaturesNVX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'computeBindingPointSupport', Bool32),
])
DeviceGeneratedCommandsFeaturesNVX.sType = u'DEVICE_GENERATED_COMMANDS_FEATURES_NVX'
DeviceGeneratedCommandsLimitsNVX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'maxIndirectCommandsLayoutTokenCount', ctypes.c_uint32),
    (u'maxObjectEntryCounts', ctypes.c_uint32),
    (u'minSequenceCountBufferOffsetAlignment', ctypes.c_uint32),
    (u'minSequenceIndexBufferOffsetAlignment', ctypes.c_uint32),
    (u'minCommandsTokenBufferOffsetAlignment', ctypes.c_uint32),
])
DeviceGeneratedCommandsLimitsNVX.sType = u'DEVICE_GENERATED_COMMANDS_LIMITS_NVX'
IndirectCommandsTokenNVX.declare([
    (u'tokenType', IndirectCommandsTokenTypeNVX),
    (u'buffer', Buffer),
    (u'offset', DeviceSize),
])
IndirectCommandsLayoutTokenNVX.declare([
    (u'tokenType', IndirectCommandsTokenTypeNVX),
    (u'bindingUnit', ctypes.c_uint32),
    (u'dynamicCount', ctypes.c_uint32),
    (u'divisor', ctypes.c_uint32),
])
IndirectCommandsLayoutCreateInfoNVX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'pipelineBindPoint', PipelineBindPoint),
    (u'flags', IndirectCommandsLayoutUsageFlagsNVX),
    (u'tokenCount', ctypes.c_uint32),
    (u'pTokens', vkbuilder.Pointer(IndirectCommandsLayoutTokenNVX)),
])
IndirectCommandsLayoutCreateInfoNVX.declare_autoarrays([
    (u'tokens', (u'tokenCount', u'pTokens')),
])
IndirectCommandsLayoutCreateInfoNVX.sType = u'INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX'
CmdProcessCommandsInfoNVX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'objectTable', ObjectTableNVX),
    (u'indirectCommandsLayout', IndirectCommandsLayoutNVX),
    (u'indirectCommandsTokenCount', ctypes.c_uint32),
    (u'pIndirectCommandsTokens', vkbuilder.Pointer(IndirectCommandsTokenNVX)),
    (u'maxSequencesCount', ctypes.c_uint32),
    (u'targetCommandBuffer', CommandBuffer),
    (u'sequencesCountBuffer', Buffer),
    (u'sequencesCountOffset', DeviceSize),
    (u'sequencesIndexBuffer', Buffer),
    (u'sequencesIndexOffset', DeviceSize),
])
CmdProcessCommandsInfoNVX.declare_autoarrays([
    (u'indirectCommandsTokens', (u'indirectCommandsTokenCount', u'pIndirectCommandsTokens')),
])
CmdProcessCommandsInfoNVX.sType = u'CMD_PROCESS_COMMANDS_INFO_NVX'
CmdReserveSpaceForCommandsInfoNVX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'objectTable', ObjectTableNVX),
    (u'indirectCommandsLayout', IndirectCommandsLayoutNVX),
    (u'maxSequencesCount', ctypes.c_uint32),
])
CmdReserveSpaceForCommandsInfoNVX.sType = u'CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX'
ObjectTableCreateInfoNVX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'objectCount', ctypes.c_uint32),
    (u'pObjectEntryTypes', vkbuilder.Pointer(ObjectEntryTypeNVX)),
    (u'pObjectEntryCounts', vkbuilder.Pointer(ctypes.c_uint32)),
    (u'pObjectEntryUsageFlags', vkbuilder.Pointer(ObjectEntryUsageFlagsNVX)),
    (u'maxUniformBuffersPerDescriptor', ctypes.c_uint32),
    (u'maxStorageBuffersPerDescriptor', ctypes.c_uint32),
    (u'maxStorageImagesPerDescriptor', ctypes.c_uint32),
    (u'maxSampledImagesPerDescriptor', ctypes.c_uint32),
    (u'maxPipelineLayouts', ctypes.c_uint32),
])
ObjectTableCreateInfoNVX.declare_autoarrays([
    (u'objectEntryTypes', (u'objectCount', u'pObjectEntryTypes')),
    (u'objectEntryCounts', (u'objectCount', u'pObjectEntryCounts')),
    (u'objectEntryUsageFlags', (u'objectCount', u'pObjectEntryUsageFlags')),
])
ObjectTableCreateInfoNVX.sType = u'OBJECT_TABLE_CREATE_INFO_NVX'
ObjectTableEntryNVX.declare([
    (u'type', ObjectEntryTypeNVX),
    (u'flags', ObjectEntryUsageFlagsNVX),
])
ObjectTablePipelineEntryNVX.declare([
    (u'type', ObjectEntryTypeNVX),
    (u'flags', ObjectEntryUsageFlagsNVX),
    (u'pipeline', Pipeline),
])
ObjectTableDescriptorSetEntryNVX.declare([
    (u'type', ObjectEntryTypeNVX),
    (u'flags', ObjectEntryUsageFlagsNVX),
    (u'pipelineLayout', PipelineLayout),
    (u'descriptorSet', DescriptorSet),
])
ObjectTableVertexBufferEntryNVX.declare([
    (u'type', ObjectEntryTypeNVX),
    (u'flags', ObjectEntryUsageFlagsNVX),
    (u'buffer', Buffer),
])
ObjectTableIndexBufferEntryNVX.declare([
    (u'type', ObjectEntryTypeNVX),
    (u'flags', ObjectEntryUsageFlagsNVX),
    (u'buffer', Buffer),
    (u'indexType', IndexType),
])
ObjectTablePushConstantEntryNVX.declare([
    (u'type', ObjectEntryTypeNVX),
    (u'flags', ObjectEntryUsageFlagsNVX),
    (u'pipelineLayout', PipelineLayout),
    (u'stageFlags', ShaderStageFlags),
])
PhysicalDeviceFeatures2KHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'features', PhysicalDeviceFeatures),
])
PhysicalDeviceFeatures2KHR.sType = u'PHYSICAL_DEVICE_FEATURES_2KHR'
PhysicalDeviceProperties2KHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'properties', PhysicalDeviceProperties),
])
PhysicalDeviceProperties2KHR.sType = u'PHYSICAL_DEVICE_PROPERTIES_2KHR'
FormatProperties2KHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'formatProperties', FormatProperties),
])
FormatProperties2KHR.sType = u'FORMAT_PROPERTIES_2KHR'
ImageFormatProperties2KHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'imageFormatProperties', ImageFormatProperties),
])
ImageFormatProperties2KHR.sType = u'IMAGE_FORMAT_PROPERTIES_2KHR'
PhysicalDeviceImageFormatInfo2KHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'format', Format),
    (u'type', ImageType),
    (u'tiling', ImageTiling),
    (u'usage', ImageUsageFlags),
    (u'flags', ImageCreateFlags),
])
PhysicalDeviceImageFormatInfo2KHR.sType = u'PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2KHR'
QueueFamilyProperties2KHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'queueFamilyProperties', QueueFamilyProperties),
])
QueueFamilyProperties2KHR.sType = u'QUEUE_FAMILY_PROPERTIES_2KHR'
PhysicalDeviceMemoryProperties2KHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'memoryProperties', PhysicalDeviceMemoryProperties),
])
PhysicalDeviceMemoryProperties2KHR.sType = u'PHYSICAL_DEVICE_MEMORY_PROPERTIES_2KHR'
SparseImageFormatProperties2KHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'properties', SparseImageFormatProperties),
])
SparseImageFormatProperties2KHR.sType = u'SPARSE_IMAGE_FORMAT_PROPERTIES_2KHR'
PhysicalDeviceSparseImageFormatInfo2KHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'format', Format),
    (u'type', ImageType),
    (u'samples', SampleCountFlags),
    (u'usage', ImageUsageFlags),
    (u'tiling', ImageTiling),
])
PhysicalDeviceSparseImageFormatInfo2KHR.sType = u'PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2KHR'
PhysicalDevicePushDescriptorPropertiesKHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'maxPushDescriptors', ctypes.c_uint32),
])
PhysicalDevicePushDescriptorPropertiesKHR.sType = u'PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR'
ExternalMemoryPropertiesKHX.declare([
    (u'externalMemoryFeatures', ExternalMemoryFeatureFlagsKHX),
    (u'exportFromImportedHandleTypes', ExternalMemoryHandleTypeFlagsKHX),
    (u'compatibleHandleTypes', ExternalMemoryHandleTypeFlagsKHX),
])
PhysicalDeviceExternalImageFormatInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'handleType', ExternalMemoryHandleTypeFlagsKHX),
])
PhysicalDeviceExternalImageFormatInfoKHX.sType = u'PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX'
ExternalImageFormatPropertiesKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'externalMemoryProperties', ExternalMemoryPropertiesKHX),
])
ExternalImageFormatPropertiesKHX.sType = u'EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX'
PhysicalDeviceExternalBufferInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', BufferCreateFlags),
    (u'usage', BufferUsageFlags),
    (u'handleType', ExternalMemoryHandleTypeFlagsKHX),
])
PhysicalDeviceExternalBufferInfoKHX.sType = u'PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX'
ExternalBufferPropertiesKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'externalMemoryProperties', ExternalMemoryPropertiesKHX),
])
ExternalBufferPropertiesKHX.sType = u'EXTERNAL_BUFFER_PROPERTIES_KHX'
PhysicalDeviceIDPropertiesKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'deviceUUID', vkbuilder.Array(ctypes.c_uint8, UUID_SIZE)),
    (u'driverUUID', vkbuilder.Array(ctypes.c_uint8, UUID_SIZE)),
    (u'deviceLUID', vkbuilder.Array(ctypes.c_uint8, LUID_SIZE_KHX)),
    (u'deviceLUIDValid', Bool32),
])
PhysicalDeviceIDPropertiesKHX.sType = u'PHYSICAL_DEVICE_IDPROPERTIES_KHX'
ExternalMemoryImageCreateInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'handleTypes', ExternalMemoryHandleTypeFlagsKHX),
])
ExternalMemoryImageCreateInfoKHX.sType = u'EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX'
ExternalMemoryBufferCreateInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'handleTypes', ExternalMemoryHandleTypeFlagsKHX),
])
ExternalMemoryBufferCreateInfoKHX.sType = u'EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX'
ExportMemoryAllocateInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'handleTypes', ExternalMemoryHandleTypeFlagsKHX),
])
ExportMemoryAllocateInfoKHX.sType = u'EXPORT_MEMORY_ALLOCATE_INFO_KHX'
ImportMemoryWin32HandleInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'handleType', ExternalMemoryHandleTypeFlagsKHX),
    (u'handle', ctypes.c_void_p),
])
ImportMemoryWin32HandleInfoKHX.sType = u'IMPORT_MEMORY_WIN_32_HANDLE_INFO_KHX'
ExportMemoryWin32HandleInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'pAttributes', vkbuilder.Pointer(ctypes.c_void_p)),
    (u'dwAccess', ctypes.c_uint32),
    (u'name', ctypes.c_void_p),
])
ExportMemoryWin32HandleInfoKHX.declare_aliases([
    (u'attributes', u'pAttributes'),
])
ExportMemoryWin32HandleInfoKHX.sType = u'EXPORT_MEMORY_WIN_32_HANDLE_INFO_KHX'
MemoryWin32HandlePropertiesKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'memoryTypeBits', ctypes.c_uint32),
])
MemoryWin32HandlePropertiesKHX.sType = u'MEMORY_WIN_32_HANDLE_PROPERTIES_KHX'
ImportMemoryFdInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'handleType', ExternalMemoryHandleTypeFlagsKHX),
    (u'fd', ctypes.c_int),
])
ImportMemoryFdInfoKHX.sType = u'IMPORT_MEMORY_FD_INFO_KHX'
MemoryFdPropertiesKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'memoryTypeBits', ctypes.c_uint32),
])
MemoryFdPropertiesKHX.sType = u'MEMORY_FD_PROPERTIES_KHX'
Win32KeyedMutexAcquireReleaseInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'acquireCount', ctypes.c_uint32),
    (u'pAcquireSyncs', vkbuilder.Pointer(DeviceMemory)),
    (u'pAcquireKeys', vkbuilder.Pointer(ctypes.c_uint64)),
    (u'pAcquireTimeouts', vkbuilder.Pointer(ctypes.c_uint32)),
    (u'releaseCount', ctypes.c_uint32),
    (u'pReleaseSyncs', vkbuilder.Pointer(DeviceMemory)),
    (u'pReleaseKeys', vkbuilder.Pointer(ctypes.c_uint64)),
])
Win32KeyedMutexAcquireReleaseInfoKHX.declare_autoarrays([
    (u'acquireSyncs', (u'acquireCount', u'pAcquireSyncs')),
    (u'acquireKeys', (u'acquireCount', u'pAcquireKeys')),
    (u'acquireTimeouts', (u'acquireCount', u'pAcquireTimeouts')),
    (u'releaseSyncs', (u'releaseCount', u'pReleaseSyncs')),
    (u'releaseKeys', (u'releaseCount', u'pReleaseKeys')),
])
Win32KeyedMutexAcquireReleaseInfoKHX.sType = u'WIN_32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX'
PhysicalDeviceExternalSemaphoreInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'handleType', ExternalSemaphoreHandleTypeFlagsKHX),
])
PhysicalDeviceExternalSemaphoreInfoKHX.sType = u'PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX'
ExternalSemaphorePropertiesKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'exportFromImportedHandleTypes', ExternalSemaphoreHandleTypeFlagsKHX),
    (u'compatibleHandleTypes', ExternalSemaphoreHandleTypeFlagsKHX),
    (u'externalSemaphoreFeatures', ExternalSemaphoreFeatureFlagsKHX),
])
ExternalSemaphorePropertiesKHX.sType = u'EXTERNAL_SEMAPHORE_PROPERTIES_KHX'
ExportSemaphoreCreateInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'handleTypes', ExternalSemaphoreHandleTypeFlagsKHX),
])
ExportSemaphoreCreateInfoKHX.sType = u'EXPORT_SEMAPHORE_CREATE_INFO_KHX'
ImportSemaphoreWin32HandleInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'semaphore', Semaphore),
    (u'handleType', ExternalSemaphoreHandleTypeFlagsKHX),
    (u'handle', ctypes.c_void_p),
])
ImportSemaphoreWin32HandleInfoKHX.sType = u'IMPORT_SEMAPHORE_WIN_32_HANDLE_INFO_KHX'
ExportSemaphoreWin32HandleInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'pAttributes', vkbuilder.Pointer(ctypes.c_void_p)),
    (u'dwAccess', ctypes.c_uint32),
    (u'name', ctypes.c_void_p),
])
ExportSemaphoreWin32HandleInfoKHX.declare_aliases([
    (u'attributes', u'pAttributes'),
])
ExportSemaphoreWin32HandleInfoKHX.sType = u'EXPORT_SEMAPHORE_WIN_32_HANDLE_INFO_KHX'
D3D12FenceSubmitInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'waitSemaphoreValuesCount', ctypes.c_uint32),
    (u'pWaitSemaphoreValues', vkbuilder.Pointer(ctypes.c_uint64)),
    (u'signalSemaphoreValuesCount', ctypes.c_uint32),
    (u'pSignalSemaphoreValues', vkbuilder.Pointer(ctypes.c_uint64)),
])
D3D12FenceSubmitInfoKHX.declare_autoarrays([
    (u'waitSemaphoreValues', (u'waitSemaphoreValuesCount', u'pWaitSemaphoreValues')),
    (u'signalSemaphoreValues', (u'signalSemaphoreValuesCount', u'pSignalSemaphoreValues')),
])
D3D12FenceSubmitInfoKHX.sType = u'D3D12_FENCE_SUBMIT_INFO_KHX'
ImportSemaphoreFdInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'semaphore', Semaphore),
    (u'handleType', ExternalSemaphoreHandleTypeFlagsKHX),
    (u'fd', ctypes.c_int),
])
ImportSemaphoreFdInfoKHX.sType = u'IMPORT_SEMAPHORE_FD_INFO_KHX'
PhysicalDeviceMultiviewFeaturesKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'multiview', Bool32),
    (u'multiviewGeometryShader', Bool32),
    (u'multiviewTessellationShader', Bool32),
])
PhysicalDeviceMultiviewFeaturesKHX.sType = u'PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX'
PhysicalDeviceMultiviewPropertiesKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'maxMultiviewViewCount', ctypes.c_uint32),
    (u'maxMultiviewInstanceIndex', ctypes.c_uint32),
])
PhysicalDeviceMultiviewPropertiesKHX.sType = u'PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX'
RenderPassMultiviewCreateInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'subpassCount', ctypes.c_uint32),
    (u'pViewMasks', vkbuilder.Pointer(ctypes.c_uint32)),
    (u'dependencyCount', ctypes.c_uint32),
    (u'pViewOffsets', vkbuilder.Pointer(ctypes.c_int32)),
    (u'correlationMaskCount', ctypes.c_uint32),
    (u'pCorrelationMasks', vkbuilder.Pointer(ctypes.c_uint32)),
])
RenderPassMultiviewCreateInfoKHX.declare_autoarrays([
    (u'viewMasks', (u'subpassCount', u'pViewMasks')),
    (u'viewOffsets', (u'dependencyCount', u'pViewOffsets')),
    (u'correlationMasks', (u'correlationMaskCount', u'pCorrelationMasks')),
])
RenderPassMultiviewCreateInfoKHX.sType = u'RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX'
SurfaceCapabilities2EXT.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'minImageCount', ctypes.c_uint32),
    (u'maxImageCount', ctypes.c_uint32),
    (u'currentExtent', Extent2D),
    (u'minImageExtent', Extent2D),
    (u'maxImageExtent', Extent2D),
    (u'maxImageArrayLayers', ctypes.c_uint32),
    (u'supportedTransforms', SurfaceTransformFlagsKHR),
    (u'currentTransform', SurfaceTransformFlagsKHR),
    (u'supportedCompositeAlpha', CompositeAlphaFlagsKHR),
    (u'supportedUsageFlags', ImageUsageFlags),
    (u'supportedSurfaceCounters', SurfaceCounterFlagsEXT),
])
SurfaceCapabilities2EXT.sType = u'SURFACE_CAPABILITIES_2EXT'
DisplayPowerInfoEXT.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'powerState', DisplayPowerStateEXT),
])
DisplayPowerInfoEXT.sType = u'DISPLAY_POWER_INFO_EXT'
DeviceEventInfoEXT.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'deviceEvent', DeviceEventTypeEXT),
])
DeviceEventInfoEXT.sType = u'DEVICE_EVENT_INFO_EXT'
DisplayEventInfoEXT.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'displayEvent', DisplayEventTypeEXT),
])
DisplayEventInfoEXT.sType = u'DISPLAY_EVENT_INFO_EXT'
SwapchainCounterCreateInfoEXT.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'surfaceCounters', SurfaceCounterFlagsEXT),
])
SwapchainCounterCreateInfoEXT.sType = u'SWAPCHAIN_COUNTER_CREATE_INFO_EXT'
PhysicalDeviceGroupPropertiesKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'physicalDeviceCount', ctypes.c_uint32),
    (u'physicalDevices', vkbuilder.Array(PhysicalDevice, MAX_DEVICE_GROUP_SIZE_KHX)),
    (u'subsetAllocation', Bool32),
])
PhysicalDeviceGroupPropertiesKHX.sType = u'PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX'
MemoryAllocateFlagsInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', MemoryAllocateFlagsKHX),
    (u'deviceMask', ctypes.c_uint32),
])
MemoryAllocateFlagsInfoKHX.sType = u'MEMORY_ALLOCATE_FLAGS_INFO_KHX'
BindBufferMemoryInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'buffer', Buffer),
    (u'memory', DeviceMemory),
    (u'memoryOffset', DeviceSize),
    (u'deviceIndexCount', ctypes.c_uint32),
    (u'pDeviceIndices', vkbuilder.Pointer(ctypes.c_uint32)),
])
BindBufferMemoryInfoKHX.declare_autoarrays([
    (u'deviceIndices', (u'deviceIndexCount', u'pDeviceIndices')),
])
BindBufferMemoryInfoKHX.sType = u'BIND_BUFFER_MEMORY_INFO_KHX'
BindImageMemoryInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'image', Image),
    (u'memory', DeviceMemory),
    (u'memoryOffset', DeviceSize),
    (u'deviceIndexCount', ctypes.c_uint32),
    (u'pDeviceIndices', vkbuilder.Pointer(ctypes.c_uint32)),
    (u'SFRRectCount', ctypes.c_uint32),
    (u'pSFRRects', vkbuilder.Pointer(Rect2D)),
])
BindImageMemoryInfoKHX.declare_autoarrays([
    (u'deviceIndices', (u'deviceIndexCount', u'pDeviceIndices')),
    (u'sFRRects', (u'SFRRectCount', u'pSFRRects')),
])
BindImageMemoryInfoKHX.sType = u'BIND_IMAGE_MEMORY_INFO_KHX'
DeviceGroupRenderPassBeginInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'deviceMask', ctypes.c_uint32),
    (u'deviceRenderAreaCount', ctypes.c_uint32),
    (u'pDeviceRenderAreas', vkbuilder.Pointer(Rect2D)),
])
DeviceGroupRenderPassBeginInfoKHX.declare_autoarrays([
    (u'deviceRenderAreas', (u'deviceRenderAreaCount', u'pDeviceRenderAreas')),
])
DeviceGroupRenderPassBeginInfoKHX.sType = u'DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX'
DeviceGroupCommandBufferBeginInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'deviceMask', ctypes.c_uint32),
])
DeviceGroupCommandBufferBeginInfoKHX.sType = u'DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX'
DeviceGroupSubmitInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'waitSemaphoreCount', ctypes.c_uint32),
    (u'pWaitSemaphoreDeviceIndices', vkbuilder.Pointer(ctypes.c_uint32)),
    (u'commandBufferCount', ctypes.c_uint32),
    (u'pCommandBufferDeviceMasks', vkbuilder.Pointer(ctypes.c_uint32)),
    (u'signalSemaphoreCount', ctypes.c_uint32),
    (u'pSignalSemaphoreDeviceIndices', vkbuilder.Pointer(ctypes.c_uint32)),
])
DeviceGroupSubmitInfoKHX.declare_autoarrays([
    (u'waitSemaphoreDeviceIndices', (u'waitSemaphoreCount', u'pWaitSemaphoreDeviceIndices')),
    (u'commandBufferDeviceMasks', (u'commandBufferCount', u'pCommandBufferDeviceMasks')),
    (u'signalSemaphoreDeviceIndices', (u'signalSemaphoreCount', u'pSignalSemaphoreDeviceIndices')),
])
DeviceGroupSubmitInfoKHX.sType = u'DEVICE_GROUP_SUBMIT_INFO_KHX'
DeviceGroupBindSparseInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'resourceDeviceIndex', ctypes.c_uint32),
    (u'memoryDeviceIndex', ctypes.c_uint32),
])
DeviceGroupBindSparseInfoKHX.sType = u'DEVICE_GROUP_BIND_SPARSE_INFO_KHX'
DeviceGroupPresentCapabilitiesKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'presentMask', vkbuilder.Array(ctypes.c_uint32, MAX_DEVICE_GROUP_SIZE_KHX)),
    (u'modes', DeviceGroupPresentModeFlagsKHX),
])
DeviceGroupPresentCapabilitiesKHX.sType = u'DEVICE_GROUP_PRESENT_CAPABILITIES_KHX'
ImageSwapchainCreateInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'swapchain', SwapchainKHR),
])
ImageSwapchainCreateInfoKHX.sType = u'IMAGE_SWAPCHAIN_CREATE_INFO_KHX'
BindImageMemorySwapchainInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'swapchain', SwapchainKHR),
    (u'imageIndex', ctypes.c_uint32),
])
BindImageMemorySwapchainInfoKHX.sType = u'BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX'
AcquireNextImageInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'swapchain', SwapchainKHR),
    (u'timeout', ctypes.c_uint64),
    (u'semaphore', Semaphore),
    (u'fence', Fence),
    (u'deviceMask', ctypes.c_uint32),
])
AcquireNextImageInfoKHX.sType = u'ACQUIRE_NEXT_IMAGE_INFO_KHX'
DeviceGroupPresentInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'swapchainCount', ctypes.c_uint32),
    (u'pDeviceMasks', vkbuilder.Pointer(ctypes.c_uint32)),
    (u'mode', DeviceGroupPresentModeFlagsKHX),
])
DeviceGroupPresentInfoKHX.declare_autoarrays([
    (u'deviceMasks', (u'swapchainCount', u'pDeviceMasks')),
])
DeviceGroupPresentInfoKHX.sType = u'DEVICE_GROUP_PRESENT_INFO_KHX'
DeviceGroupDeviceCreateInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'physicalDeviceCount', ctypes.c_uint32),
    (u'pPhysicalDevices', vkbuilder.Pointer(PhysicalDevice)),
])
DeviceGroupDeviceCreateInfoKHX.declare_autoarrays([
    (u'physicalDevices', (u'physicalDeviceCount', u'pPhysicalDevices')),
])
DeviceGroupDeviceCreateInfoKHX.sType = u'DEVICE_GROUP_DEVICE_CREATE_INFO_KHX'
DeviceGroupSwapchainCreateInfoKHX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'modes', DeviceGroupPresentModeFlagsKHX),
])
DeviceGroupSwapchainCreateInfoKHX.sType = u'DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX'
DescriptorUpdateTemplateEntryKHR.declare([
    (u'dstBinding', ctypes.c_uint32),
    (u'dstArrayElement', ctypes.c_uint32),
    (u'descriptorCount', ctypes.c_uint32),
    (u'descriptorType', DescriptorType),
    (u'offset', ctypes.c_size_t),
    (u'stride', ctypes.c_size_t),
])
DescriptorUpdateTemplateCreateInfoKHR.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', DescriptorUpdateTemplateCreateFlagsKHR),
    (u'descriptorUpdateEntryCount', ctypes.c_uint32),
    (u'pDescriptorUpdateEntries', vkbuilder.Pointer(DescriptorUpdateTemplateEntryKHR)),
    (u'templateType', DescriptorUpdateTemplateTypeKHR),
    (u'descriptorSetLayout', DescriptorSetLayout),
    (u'pipelineBindPoint', PipelineBindPoint),
    (u'pipelineLayout', PipelineLayout),
    (u'set', ctypes.c_uint32),
])
DescriptorUpdateTemplateCreateInfoKHR.declare_autoarrays([
    (u'descriptorUpdateEntries', (u'descriptorUpdateEntryCount', u'pDescriptorUpdateEntries')),
])
DescriptorUpdateTemplateCreateInfoKHR.sType = u'DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR'
XYColorEXT.declare([
    (u'x', ctypes.c_float),
    (u'y', ctypes.c_float),
])
HdrMetadataEXT.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'displayPrimaryRed', XYColorEXT),
    (u'displayPrimaryGreen', XYColorEXT),
    (u'displayPrimaryBlue', XYColorEXT),
    (u'whitePoint', XYColorEXT),
    (u'maxLuminance', ctypes.c_float),
    (u'minLuminance', ctypes.c_float),
    (u'maxContentLightLevel', ctypes.c_float),
    (u'maxFrameAverageLightLevel', ctypes.c_float),
])
HdrMetadataEXT.sType = u'HDR_METADATA_EXT'
RefreshCycleDurationGOOGLE.declare([
    (u'refreshDuration', ctypes.c_uint64),
])
PastPresentationTimingGOOGLE.declare([
    (u'presentID', ctypes.c_uint32),
    (u'desiredPresentTime', ctypes.c_uint64),
    (u'actualPresentTime', ctypes.c_uint64),
    (u'earliestPresentTime', ctypes.c_uint64),
    (u'presentMargin', ctypes.c_uint64),
])
PresentTimesInfoGOOGLE.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'swapchainCount', ctypes.c_uint32),
    (u'pTimes', vkbuilder.Pointer(PresentTimeGOOGLE)),
])
PresentTimesInfoGOOGLE.declare_autoarrays([
    (u'times', (u'swapchainCount', u'pTimes')),
])
PresentTimesInfoGOOGLE.sType = u'PRESENT_TIMES_INFO_GOOGLE'
PresentTimeGOOGLE.declare([
    (u'presentID', ctypes.c_uint32),
    (u'desiredPresentTime', ctypes.c_uint64),
])
IOSSurfaceCreateInfoMVK.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', IOSSurfaceCreateFlagsMVK),
    (u'pView', ctypes.c_void_p),
])
IOSSurfaceCreateInfoMVK.declare_aliases([
    (u'view', u'pView'),
])
IOSSurfaceCreateInfoMVK.sType = u'IOSSURFACE_CREATE_INFO_MVK'
MacOSSurfaceCreateInfoMVK.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', MacOSSurfaceCreateFlagsMVK),
    (u'pView', ctypes.c_void_p),
])
MacOSSurfaceCreateInfoMVK.declare_aliases([
    (u'view', u'pView'),
])
MacOSSurfaceCreateInfoMVK.sType = u'MAC_OSSURFACE_CREATE_INFO_MVK'
ViewportWScalingNV.declare([
    (u'xcoeff', ctypes.c_float),
    (u'ycoeff', ctypes.c_float),
])
PipelineViewportWScalingStateCreateInfoNV.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'viewportWScalingEnable', Bool32),
    (u'viewportCount', ctypes.c_uint32),
    (u'pViewportWScalings', vkbuilder.Pointer(ViewportWScalingNV)),
])
PipelineViewportWScalingStateCreateInfoNV.declare_autoarrays([
    (u'viewportWScalings', (u'viewportCount', u'pViewportWScalings')),
])
PipelineViewportWScalingStateCreateInfoNV.sType = u'PIPELINE_VIEWPORT_WSCALING_STATE_CREATE_INFO_NV'
ViewportSwizzleNV.declare([
    (u'x', ViewportCoordinateSwizzleNV),
    (u'y', ViewportCoordinateSwizzleNV),
    (u'z', ViewportCoordinateSwizzleNV),
    (u'w', ViewportCoordinateSwizzleNV),
])
PipelineViewportSwizzleStateCreateInfoNV.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', PipelineViewportSwizzleStateCreateFlagsNV),
    (u'viewportCount', ctypes.c_uint32),
    (u'pViewportSwizzles', vkbuilder.Pointer(ViewportSwizzleNV)),
])
PipelineViewportSwizzleStateCreateInfoNV.declare_autoarrays([
    (u'viewportSwizzles', (u'viewportCount', u'pViewportSwizzles')),
])
PipelineViewportSwizzleStateCreateInfoNV.sType = u'PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV'
PhysicalDeviceDiscardRectanglePropertiesEXT.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'maxDiscardRectangles', ctypes.c_uint32),
])
PhysicalDeviceDiscardRectanglePropertiesEXT.sType = u'PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT'
PipelineDiscardRectangleStateCreateInfoEXT.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'flags', PipelineDiscardRectangleStateCreateFlagsEXT),
    (u'discardRectangleMode', DiscardRectangleModeEXT),
    (u'discardRectangleCount', ctypes.c_uint32),
    (u'pDiscardRectangles', vkbuilder.Pointer(Rect2D)),
])
PipelineDiscardRectangleStateCreateInfoEXT.declare_autoarrays([
    (u'discardRectangles', (u'discardRectangleCount', u'pDiscardRectangles')),
])
PipelineDiscardRectangleStateCreateInfoEXT.sType = u'PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT'
PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.declare([
    (u'sType', StructureType),
    (u'pNext', ctypes.c_void_p),
    (u'perViewPositionAllComponents', Bool32),
])
PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.sType = u'PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX'

try:
    createInstance = lib.vkCreateInstance
except AttributeError as e: pass
else:
    createInstance.restype = ResultCheck
    createInstance.argtypes = [ 
        vkbuilder.Pointer(InstanceCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(Instance),
    ]

try:
    destroyInstance = lib.vkDestroyInstance
except AttributeError as e: pass
else:
    destroyInstance.restype = None
    destroyInstance.argtypes = [ 
        Instance,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    enumeratePhysicalDevices = lib.vkEnumeratePhysicalDevices
except AttributeError as e: pass
else:
    enumeratePhysicalDevices.restype = ResultCheck
    enumeratePhysicalDevices.argtypes = [ 
        Instance,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(PhysicalDevice),
    ]

try:
    getDeviceProcAddr = lib.vkGetDeviceProcAddr
except AttributeError as e: pass
else:
    getDeviceProcAddr.restype = PFN_VoidFunction
    getDeviceProcAddr.argtypes = [ 
        Device,
        ctypes.c_char_p,
    ]

try:
    getInstanceProcAddr = lib.vkGetInstanceProcAddr
except AttributeError as e: pass
else:
    getInstanceProcAddr.restype = PFN_VoidFunction
    getInstanceProcAddr.argtypes = [ 
        Instance,
        ctypes.c_char_p,
    ]

try:
    getPhysicalDeviceProperties = lib.vkGetPhysicalDeviceProperties
except AttributeError as e: pass
else:
    getPhysicalDeviceProperties.restype = None
    getPhysicalDeviceProperties.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(PhysicalDeviceProperties),
    ]

try:
    getPhysicalDeviceQueueFamilyProperties = lib.vkGetPhysicalDeviceQueueFamilyProperties
except AttributeError as e: pass
else:
    getPhysicalDeviceQueueFamilyProperties.restype = None
    getPhysicalDeviceQueueFamilyProperties.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(QueueFamilyProperties),
    ]

try:
    getPhysicalDeviceMemoryProperties = lib.vkGetPhysicalDeviceMemoryProperties
except AttributeError as e: pass
else:
    getPhysicalDeviceMemoryProperties.restype = None
    getPhysicalDeviceMemoryProperties.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(PhysicalDeviceMemoryProperties),
    ]

try:
    getPhysicalDeviceFeatures = lib.vkGetPhysicalDeviceFeatures
except AttributeError as e: pass
else:
    getPhysicalDeviceFeatures.restype = None
    getPhysicalDeviceFeatures.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(PhysicalDeviceFeatures),
    ]

try:
    getPhysicalDeviceFormatProperties = lib.vkGetPhysicalDeviceFormatProperties
except AttributeError as e: pass
else:
    getPhysicalDeviceFormatProperties.restype = None
    getPhysicalDeviceFormatProperties.argtypes = [ 
        PhysicalDevice,
        Format,
        vkbuilder.Pointer(FormatProperties),
    ]

try:
    getPhysicalDeviceImageFormatProperties = lib.vkGetPhysicalDeviceImageFormatProperties
except AttributeError as e: pass
else:
    getPhysicalDeviceImageFormatProperties.restype = ResultCheck
    getPhysicalDeviceImageFormatProperties.argtypes = [ 
        PhysicalDevice,
        Format,
        ImageType,
        ImageTiling,
        ImageUsageFlags,
        ImageCreateFlags,
        vkbuilder.Pointer(ImageFormatProperties),
    ]

try:
    createDevice = lib.vkCreateDevice
except AttributeError as e: pass
else:
    createDevice.restype = ResultCheck
    createDevice.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(DeviceCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(Device),
    ]

try:
    destroyDevice = lib.vkDestroyDevice
except AttributeError as e: pass
else:
    destroyDevice.restype = None
    destroyDevice.argtypes = [ 
        Device,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    enumerateInstanceLayerProperties = lib.vkEnumerateInstanceLayerProperties
except AttributeError as e: pass
else:
    enumerateInstanceLayerProperties.restype = ResultCheck
    enumerateInstanceLayerProperties.argtypes = [ 
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(LayerProperties),
    ]

try:
    enumerateInstanceExtensionProperties = lib.vkEnumerateInstanceExtensionProperties
except AttributeError as e: pass
else:
    enumerateInstanceExtensionProperties.restype = ResultCheck
    enumerateInstanceExtensionProperties.argtypes = [ 
        ctypes.c_char_p,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(ExtensionProperties),
    ]

try:
    enumerateDeviceLayerProperties = lib.vkEnumerateDeviceLayerProperties
except AttributeError as e: pass
else:
    enumerateDeviceLayerProperties.restype = ResultCheck
    enumerateDeviceLayerProperties.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(LayerProperties),
    ]

try:
    enumerateDeviceExtensionProperties = lib.vkEnumerateDeviceExtensionProperties
except AttributeError as e: pass
else:
    enumerateDeviceExtensionProperties.restype = ResultCheck
    enumerateDeviceExtensionProperties.argtypes = [ 
        PhysicalDevice,
        ctypes.c_char_p,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(ExtensionProperties),
    ]

try:
    getDeviceQueue = lib.vkGetDeviceQueue
except AttributeError as e: pass
else:
    getDeviceQueue.restype = None
    getDeviceQueue.argtypes = [ 
        Device,
        ctypes.c_uint32,
        ctypes.c_uint32,
        vkbuilder.Pointer(Queue),
    ]

try:
    queueSubmit = lib.vkQueueSubmit
except AttributeError as e: pass
else:
    queueSubmit.restype = ResultCheck
    queueSubmit.argtypes = [ 
        Queue,
        ctypes.c_uint32,
        vkbuilder.Pointer(SubmitInfo),
        Fence,
    ]

try:
    queueWaitIdle = lib.vkQueueWaitIdle
except AttributeError as e: pass
else:
    queueWaitIdle.restype = ResultCheck
    queueWaitIdle.argtypes = [ 
        Queue,
    ]

try:
    deviceWaitIdle = lib.vkDeviceWaitIdle
except AttributeError as e: pass
else:
    deviceWaitIdle.restype = ResultCheck
    deviceWaitIdle.argtypes = [ 
        Device,
    ]

try:
    allocateMemory = lib.vkAllocateMemory
except AttributeError as e: pass
else:
    allocateMemory.restype = ResultCheck
    allocateMemory.argtypes = [ 
        Device,
        vkbuilder.Pointer(MemoryAllocateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(DeviceMemory),
    ]

try:
    freeMemory = lib.vkFreeMemory
except AttributeError as e: pass
else:
    freeMemory.restype = None
    freeMemory.argtypes = [ 
        Device,
        DeviceMemory,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    mapMemory = lib.vkMapMemory
except AttributeError as e: pass
else:
    mapMemory.restype = ResultCheck
    mapMemory.argtypes = [ 
        Device,
        DeviceMemory,
        DeviceSize,
        DeviceSize,
        MemoryMapFlags,
        vkbuilder.Pointer(ctypes.c_void_p),
    ]

try:
    unmapMemory = lib.vkUnmapMemory
except AttributeError as e: pass
else:
    unmapMemory.restype = None
    unmapMemory.argtypes = [ 
        Device,
        DeviceMemory,
    ]

try:
    flushMappedMemoryRanges = lib.vkFlushMappedMemoryRanges
except AttributeError as e: pass
else:
    flushMappedMemoryRanges.restype = ResultCheck
    flushMappedMemoryRanges.argtypes = [ 
        Device,
        ctypes.c_uint32,
        vkbuilder.Pointer(MappedMemoryRange),
    ]

try:
    invalidateMappedMemoryRanges = lib.vkInvalidateMappedMemoryRanges
except AttributeError as e: pass
else:
    invalidateMappedMemoryRanges.restype = ResultCheck
    invalidateMappedMemoryRanges.argtypes = [ 
        Device,
        ctypes.c_uint32,
        vkbuilder.Pointer(MappedMemoryRange),
    ]

try:
    getDeviceMemoryCommitment = lib.vkGetDeviceMemoryCommitment
except AttributeError as e: pass
else:
    getDeviceMemoryCommitment.restype = None
    getDeviceMemoryCommitment.argtypes = [ 
        Device,
        DeviceMemory,
        vkbuilder.Pointer(DeviceSize),
    ]

try:
    getBufferMemoryRequirements = lib.vkGetBufferMemoryRequirements
except AttributeError as e: pass
else:
    getBufferMemoryRequirements.restype = None
    getBufferMemoryRequirements.argtypes = [ 
        Device,
        Buffer,
        vkbuilder.Pointer(MemoryRequirements),
    ]

try:
    bindBufferMemory = lib.vkBindBufferMemory
except AttributeError as e: pass
else:
    bindBufferMemory.restype = ResultCheck
    bindBufferMemory.argtypes = [ 
        Device,
        Buffer,
        DeviceMemory,
        DeviceSize,
    ]

try:
    getImageMemoryRequirements = lib.vkGetImageMemoryRequirements
except AttributeError as e: pass
else:
    getImageMemoryRequirements.restype = None
    getImageMemoryRequirements.argtypes = [ 
        Device,
        Image,
        vkbuilder.Pointer(MemoryRequirements),
    ]

try:
    bindImageMemory = lib.vkBindImageMemory
except AttributeError as e: pass
else:
    bindImageMemory.restype = ResultCheck
    bindImageMemory.argtypes = [ 
        Device,
        Image,
        DeviceMemory,
        DeviceSize,
    ]

try:
    getImageSparseMemoryRequirements = lib.vkGetImageSparseMemoryRequirements
except AttributeError as e: pass
else:
    getImageSparseMemoryRequirements.restype = None
    getImageSparseMemoryRequirements.argtypes = [ 
        Device,
        Image,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(SparseImageMemoryRequirements),
    ]

try:
    getPhysicalDeviceSparseImageFormatProperties = lib.vkGetPhysicalDeviceSparseImageFormatProperties
except AttributeError as e: pass
else:
    getPhysicalDeviceSparseImageFormatProperties.restype = None
    getPhysicalDeviceSparseImageFormatProperties.argtypes = [ 
        PhysicalDevice,
        Format,
        ImageType,
        SampleCountFlags,
        ImageUsageFlags,
        ImageTiling,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(SparseImageFormatProperties),
    ]

try:
    queueBindSparse = lib.vkQueueBindSparse
except AttributeError as e: pass
else:
    queueBindSparse.restype = ResultCheck
    queueBindSparse.argtypes = [ 
        Queue,
        ctypes.c_uint32,
        vkbuilder.Pointer(BindSparseInfo),
        Fence,
    ]

try:
    createFence = lib.vkCreateFence
except AttributeError as e: pass
else:
    createFence.restype = ResultCheck
    createFence.argtypes = [ 
        Device,
        vkbuilder.Pointer(FenceCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(Fence),
    ]

try:
    destroyFence = lib.vkDestroyFence
except AttributeError as e: pass
else:
    destroyFence.restype = None
    destroyFence.argtypes = [ 
        Device,
        Fence,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    resetFences = lib.vkResetFences
except AttributeError as e: pass
else:
    resetFences.restype = ResultCheck
    resetFences.argtypes = [ 
        Device,
        ctypes.c_uint32,
        vkbuilder.Pointer(Fence),
    ]

try:
    getFenceStatus = lib.vkGetFenceStatus
except AttributeError as e: pass
else:
    getFenceStatus.restype = ResultCheck
    getFenceStatus.argtypes = [ 
        Device,
        Fence,
    ]

try:
    waitForFences = lib.vkWaitForFences
except AttributeError as e: pass
else:
    waitForFences.restype = ResultCheck
    waitForFences.argtypes = [ 
        Device,
        ctypes.c_uint32,
        vkbuilder.Pointer(Fence),
        Bool32,
        ctypes.c_uint64,
    ]

try:
    createSemaphore = lib.vkCreateSemaphore
except AttributeError as e: pass
else:
    createSemaphore.restype = ResultCheck
    createSemaphore.argtypes = [ 
        Device,
        vkbuilder.Pointer(SemaphoreCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(Semaphore),
    ]

try:
    destroySemaphore = lib.vkDestroySemaphore
except AttributeError as e: pass
else:
    destroySemaphore.restype = None
    destroySemaphore.argtypes = [ 
        Device,
        Semaphore,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    createEvent = lib.vkCreateEvent
except AttributeError as e: pass
else:
    createEvent.restype = ResultCheck
    createEvent.argtypes = [ 
        Device,
        vkbuilder.Pointer(EventCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(Event),
    ]

try:
    destroyEvent = lib.vkDestroyEvent
except AttributeError as e: pass
else:
    destroyEvent.restype = None
    destroyEvent.argtypes = [ 
        Device,
        Event,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    getEventStatus = lib.vkGetEventStatus
except AttributeError as e: pass
else:
    getEventStatus.restype = ResultCheck
    getEventStatus.argtypes = [ 
        Device,
        Event,
    ]

try:
    setEvent = lib.vkSetEvent
except AttributeError as e: pass
else:
    setEvent.restype = ResultCheck
    setEvent.argtypes = [ 
        Device,
        Event,
    ]

try:
    resetEvent = lib.vkResetEvent
except AttributeError as e: pass
else:
    resetEvent.restype = ResultCheck
    resetEvent.argtypes = [ 
        Device,
        Event,
    ]

try:
    createQueryPool = lib.vkCreateQueryPool
except AttributeError as e: pass
else:
    createQueryPool.restype = ResultCheck
    createQueryPool.argtypes = [ 
        Device,
        vkbuilder.Pointer(QueryPoolCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(QueryPool),
    ]

try:
    destroyQueryPool = lib.vkDestroyQueryPool
except AttributeError as e: pass
else:
    destroyQueryPool.restype = None
    destroyQueryPool.argtypes = [ 
        Device,
        QueryPool,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    getQueryPoolResults = lib.vkGetQueryPoolResults
except AttributeError as e: pass
else:
    getQueryPoolResults.restype = ResultCheck
    getQueryPoolResults.argtypes = [ 
        Device,
        QueryPool,
        ctypes.c_uint32,
        ctypes.c_uint32,
        ctypes.c_size_t,
        ctypes.c_void_p,
        DeviceSize,
        QueryResultFlags,
    ]

try:
    createBuffer = lib.vkCreateBuffer
except AttributeError as e: pass
else:
    createBuffer.restype = ResultCheck
    createBuffer.argtypes = [ 
        Device,
        vkbuilder.Pointer(BufferCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(Buffer),
    ]

try:
    destroyBuffer = lib.vkDestroyBuffer
except AttributeError as e: pass
else:
    destroyBuffer.restype = None
    destroyBuffer.argtypes = [ 
        Device,
        Buffer,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    createBufferView = lib.vkCreateBufferView
except AttributeError as e: pass
else:
    createBufferView.restype = ResultCheck
    createBufferView.argtypes = [ 
        Device,
        vkbuilder.Pointer(BufferViewCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(BufferView),
    ]

try:
    destroyBufferView = lib.vkDestroyBufferView
except AttributeError as e: pass
else:
    destroyBufferView.restype = None
    destroyBufferView.argtypes = [ 
        Device,
        BufferView,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    createImage = lib.vkCreateImage
except AttributeError as e: pass
else:
    createImage.restype = ResultCheck
    createImage.argtypes = [ 
        Device,
        vkbuilder.Pointer(ImageCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(Image),
    ]

try:
    destroyImage = lib.vkDestroyImage
except AttributeError as e: pass
else:
    destroyImage.restype = None
    destroyImage.argtypes = [ 
        Device,
        Image,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    getImageSubresourceLayout = lib.vkGetImageSubresourceLayout
except AttributeError as e: pass
else:
    getImageSubresourceLayout.restype = None
    getImageSubresourceLayout.argtypes = [ 
        Device,
        Image,
        vkbuilder.Pointer(ImageSubresource),
        vkbuilder.Pointer(SubresourceLayout),
    ]

try:
    createImageView = lib.vkCreateImageView
except AttributeError as e: pass
else:
    createImageView.restype = ResultCheck
    createImageView.argtypes = [ 
        Device,
        vkbuilder.Pointer(ImageViewCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(ImageView),
    ]

try:
    destroyImageView = lib.vkDestroyImageView
except AttributeError as e: pass
else:
    destroyImageView.restype = None
    destroyImageView.argtypes = [ 
        Device,
        ImageView,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    createShaderModule = lib.vkCreateShaderModule
except AttributeError as e: pass
else:
    createShaderModule.restype = ResultCheck
    createShaderModule.argtypes = [ 
        Device,
        vkbuilder.Pointer(ShaderModuleCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(ShaderModule),
    ]

try:
    destroyShaderModule = lib.vkDestroyShaderModule
except AttributeError as e: pass
else:
    destroyShaderModule.restype = None
    destroyShaderModule.argtypes = [ 
        Device,
        ShaderModule,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    createPipelineCache = lib.vkCreatePipelineCache
except AttributeError as e: pass
else:
    createPipelineCache.restype = ResultCheck
    createPipelineCache.argtypes = [ 
        Device,
        vkbuilder.Pointer(PipelineCacheCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(PipelineCache),
    ]

try:
    destroyPipelineCache = lib.vkDestroyPipelineCache
except AttributeError as e: pass
else:
    destroyPipelineCache.restype = None
    destroyPipelineCache.argtypes = [ 
        Device,
        PipelineCache,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    getPipelineCacheData = lib.vkGetPipelineCacheData
except AttributeError as e: pass
else:
    getPipelineCacheData.restype = ResultCheck
    getPipelineCacheData.argtypes = [ 
        Device,
        PipelineCache,
        vkbuilder.Pointer(ctypes.c_size_t),
        ctypes.c_void_p,
    ]

try:
    mergePipelineCaches = lib.vkMergePipelineCaches
except AttributeError as e: pass
else:
    mergePipelineCaches.restype = ResultCheck
    mergePipelineCaches.argtypes = [ 
        Device,
        PipelineCache,
        ctypes.c_uint32,
        vkbuilder.Pointer(PipelineCache),
    ]

try:
    createGraphicsPipelines = lib.vkCreateGraphicsPipelines
except AttributeError as e: pass
else:
    createGraphicsPipelines.restype = ResultCheck
    createGraphicsPipelines.argtypes = [ 
        Device,
        PipelineCache,
        ctypes.c_uint32,
        vkbuilder.Pointer(GraphicsPipelineCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(Pipeline),
    ]

try:
    createComputePipelines = lib.vkCreateComputePipelines
except AttributeError as e: pass
else:
    createComputePipelines.restype = ResultCheck
    createComputePipelines.argtypes = [ 
        Device,
        PipelineCache,
        ctypes.c_uint32,
        vkbuilder.Pointer(ComputePipelineCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(Pipeline),
    ]

try:
    destroyPipeline = lib.vkDestroyPipeline
except AttributeError as e: pass
else:
    destroyPipeline.restype = None
    destroyPipeline.argtypes = [ 
        Device,
        Pipeline,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    createPipelineLayout = lib.vkCreatePipelineLayout
except AttributeError as e: pass
else:
    createPipelineLayout.restype = ResultCheck
    createPipelineLayout.argtypes = [ 
        Device,
        vkbuilder.Pointer(PipelineLayoutCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(PipelineLayout),
    ]

try:
    destroyPipelineLayout = lib.vkDestroyPipelineLayout
except AttributeError as e: pass
else:
    destroyPipelineLayout.restype = None
    destroyPipelineLayout.argtypes = [ 
        Device,
        PipelineLayout,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    createSampler = lib.vkCreateSampler
except AttributeError as e: pass
else:
    createSampler.restype = ResultCheck
    createSampler.argtypes = [ 
        Device,
        vkbuilder.Pointer(SamplerCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(Sampler),
    ]

try:
    destroySampler = lib.vkDestroySampler
except AttributeError as e: pass
else:
    destroySampler.restype = None
    destroySampler.argtypes = [ 
        Device,
        Sampler,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    createDescriptorSetLayout = lib.vkCreateDescriptorSetLayout
except AttributeError as e: pass
else:
    createDescriptorSetLayout.restype = ResultCheck
    createDescriptorSetLayout.argtypes = [ 
        Device,
        vkbuilder.Pointer(DescriptorSetLayoutCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(DescriptorSetLayout),
    ]

try:
    destroyDescriptorSetLayout = lib.vkDestroyDescriptorSetLayout
except AttributeError as e: pass
else:
    destroyDescriptorSetLayout.restype = None
    destroyDescriptorSetLayout.argtypes = [ 
        Device,
        DescriptorSetLayout,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    createDescriptorPool = lib.vkCreateDescriptorPool
except AttributeError as e: pass
else:
    createDescriptorPool.restype = ResultCheck
    createDescriptorPool.argtypes = [ 
        Device,
        vkbuilder.Pointer(DescriptorPoolCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(DescriptorPool),
    ]

try:
    destroyDescriptorPool = lib.vkDestroyDescriptorPool
except AttributeError as e: pass
else:
    destroyDescriptorPool.restype = None
    destroyDescriptorPool.argtypes = [ 
        Device,
        DescriptorPool,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    resetDescriptorPool = lib.vkResetDescriptorPool
except AttributeError as e: pass
else:
    resetDescriptorPool.restype = ResultCheck
    resetDescriptorPool.argtypes = [ 
        Device,
        DescriptorPool,
        DescriptorPoolResetFlags,
    ]

try:
    allocateDescriptorSets = lib.vkAllocateDescriptorSets
except AttributeError as e: pass
else:
    allocateDescriptorSets.restype = ResultCheck
    allocateDescriptorSets.argtypes = [ 
        Device,
        vkbuilder.Pointer(DescriptorSetAllocateInfo),
        vkbuilder.Pointer(DescriptorSet),
    ]

try:
    freeDescriptorSets = lib.vkFreeDescriptorSets
except AttributeError as e: pass
else:
    freeDescriptorSets.restype = ResultCheck
    freeDescriptorSets.argtypes = [ 
        Device,
        DescriptorPool,
        ctypes.c_uint32,
        vkbuilder.Pointer(DescriptorSet),
    ]

try:
    updateDescriptorSets = lib.vkUpdateDescriptorSets
except AttributeError as e: pass
else:
    updateDescriptorSets.restype = None
    updateDescriptorSets.argtypes = [ 
        Device,
        ctypes.c_uint32,
        vkbuilder.Pointer(WriteDescriptorSet),
        ctypes.c_uint32,
        vkbuilder.Pointer(CopyDescriptorSet),
    ]

try:
    createFramebuffer = lib.vkCreateFramebuffer
except AttributeError as e: pass
else:
    createFramebuffer.restype = ResultCheck
    createFramebuffer.argtypes = [ 
        Device,
        vkbuilder.Pointer(FramebufferCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(Framebuffer),
    ]

try:
    destroyFramebuffer = lib.vkDestroyFramebuffer
except AttributeError as e: pass
else:
    destroyFramebuffer.restype = None
    destroyFramebuffer.argtypes = [ 
        Device,
        Framebuffer,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    createRenderPass = lib.vkCreateRenderPass
except AttributeError as e: pass
else:
    createRenderPass.restype = ResultCheck
    createRenderPass.argtypes = [ 
        Device,
        vkbuilder.Pointer(RenderPassCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(RenderPass),
    ]

try:
    destroyRenderPass = lib.vkDestroyRenderPass
except AttributeError as e: pass
else:
    destroyRenderPass.restype = None
    destroyRenderPass.argtypes = [ 
        Device,
        RenderPass,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    getRenderAreaGranularity = lib.vkGetRenderAreaGranularity
except AttributeError as e: pass
else:
    getRenderAreaGranularity.restype = None
    getRenderAreaGranularity.argtypes = [ 
        Device,
        RenderPass,
        vkbuilder.Pointer(Extent2D),
    ]

try:
    createCommandPool = lib.vkCreateCommandPool
except AttributeError as e: pass
else:
    createCommandPool.restype = ResultCheck
    createCommandPool.argtypes = [ 
        Device,
        vkbuilder.Pointer(CommandPoolCreateInfo),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(CommandPool),
    ]

try:
    destroyCommandPool = lib.vkDestroyCommandPool
except AttributeError as e: pass
else:
    destroyCommandPool.restype = None
    destroyCommandPool.argtypes = [ 
        Device,
        CommandPool,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    resetCommandPool = lib.vkResetCommandPool
except AttributeError as e: pass
else:
    resetCommandPool.restype = ResultCheck
    resetCommandPool.argtypes = [ 
        Device,
        CommandPool,
        CommandPoolResetFlags,
    ]

try:
    allocateCommandBuffers = lib.vkAllocateCommandBuffers
except AttributeError as e: pass
else:
    allocateCommandBuffers.restype = ResultCheck
    allocateCommandBuffers.argtypes = [ 
        Device,
        vkbuilder.Pointer(CommandBufferAllocateInfo),
        vkbuilder.Pointer(CommandBuffer),
    ]

try:
    freeCommandBuffers = lib.vkFreeCommandBuffers
except AttributeError as e: pass
else:
    freeCommandBuffers.restype = None
    freeCommandBuffers.argtypes = [ 
        Device,
        CommandPool,
        ctypes.c_uint32,
        vkbuilder.Pointer(CommandBuffer),
    ]

try:
    beginCommandBuffer = lib.vkBeginCommandBuffer
except AttributeError as e: pass
else:
    beginCommandBuffer.restype = ResultCheck
    beginCommandBuffer.argtypes = [ 
        CommandBuffer,
        vkbuilder.Pointer(CommandBufferBeginInfo),
    ]

try:
    endCommandBuffer = lib.vkEndCommandBuffer
except AttributeError as e: pass
else:
    endCommandBuffer.restype = ResultCheck
    endCommandBuffer.argtypes = [ 
        CommandBuffer,
    ]

try:
    resetCommandBuffer = lib.vkResetCommandBuffer
except AttributeError as e: pass
else:
    resetCommandBuffer.restype = ResultCheck
    resetCommandBuffer.argtypes = [ 
        CommandBuffer,
        CommandBufferResetFlags,
    ]

try:
    cmdBindPipeline = lib.vkCmdBindPipeline
except AttributeError as e: pass
else:
    cmdBindPipeline.restype = None
    cmdBindPipeline.argtypes = [ 
        CommandBuffer,
        PipelineBindPoint,
        Pipeline,
    ]

try:
    cmdSetViewport = lib.vkCmdSetViewport
except AttributeError as e: pass
else:
    cmdSetViewport.restype = None
    cmdSetViewport.argtypes = [ 
        CommandBuffer,
        ctypes.c_uint32,
        ctypes.c_uint32,
        vkbuilder.Pointer(Viewport),
    ]

try:
    cmdSetScissor = lib.vkCmdSetScissor
except AttributeError as e: pass
else:
    cmdSetScissor.restype = None
    cmdSetScissor.argtypes = [ 
        CommandBuffer,
        ctypes.c_uint32,
        ctypes.c_uint32,
        vkbuilder.Pointer(Rect2D),
    ]

try:
    cmdSetLineWidth = lib.vkCmdSetLineWidth
except AttributeError as e: pass
else:
    cmdSetLineWidth.restype = None
    cmdSetLineWidth.argtypes = [ 
        CommandBuffer,
        ctypes.c_float,
    ]

try:
    cmdSetDepthBias = lib.vkCmdSetDepthBias
except AttributeError as e: pass
else:
    cmdSetDepthBias.restype = None
    cmdSetDepthBias.argtypes = [ 
        CommandBuffer,
        ctypes.c_float,
        ctypes.c_float,
        ctypes.c_float,
    ]

try:
    cmdSetBlendConstants = lib.vkCmdSetBlendConstants
except AttributeError as e: pass
else:
    cmdSetBlendConstants.restype = None
    cmdSetBlendConstants.argtypes = [ 
        CommandBuffer,
        vkbuilder.Array(ctypes.c_float, 4),
    ]

try:
    cmdSetDepthBounds = lib.vkCmdSetDepthBounds
except AttributeError as e: pass
else:
    cmdSetDepthBounds.restype = None
    cmdSetDepthBounds.argtypes = [ 
        CommandBuffer,
        ctypes.c_float,
        ctypes.c_float,
    ]

try:
    cmdSetStencilCompareMask = lib.vkCmdSetStencilCompareMask
except AttributeError as e: pass
else:
    cmdSetStencilCompareMask.restype = None
    cmdSetStencilCompareMask.argtypes = [ 
        CommandBuffer,
        StencilFaceFlags,
        ctypes.c_uint32,
    ]

try:
    cmdSetStencilWriteMask = lib.vkCmdSetStencilWriteMask
except AttributeError as e: pass
else:
    cmdSetStencilWriteMask.restype = None
    cmdSetStencilWriteMask.argtypes = [ 
        CommandBuffer,
        StencilFaceFlags,
        ctypes.c_uint32,
    ]

try:
    cmdSetStencilReference = lib.vkCmdSetStencilReference
except AttributeError as e: pass
else:
    cmdSetStencilReference.restype = None
    cmdSetStencilReference.argtypes = [ 
        CommandBuffer,
        StencilFaceFlags,
        ctypes.c_uint32,
    ]

try:
    cmdBindDescriptorSets = lib.vkCmdBindDescriptorSets
except AttributeError as e: pass
else:
    cmdBindDescriptorSets.restype = None
    cmdBindDescriptorSets.argtypes = [ 
        CommandBuffer,
        PipelineBindPoint,
        PipelineLayout,
        ctypes.c_uint32,
        ctypes.c_uint32,
        vkbuilder.Pointer(DescriptorSet),
        ctypes.c_uint32,
        vkbuilder.Pointer(ctypes.c_uint32),
    ]

try:
    cmdBindIndexBuffer = lib.vkCmdBindIndexBuffer
except AttributeError as e: pass
else:
    cmdBindIndexBuffer.restype = None
    cmdBindIndexBuffer.argtypes = [ 
        CommandBuffer,
        Buffer,
        DeviceSize,
        IndexType,
    ]

try:
    cmdBindVertexBuffers = lib.vkCmdBindVertexBuffers
except AttributeError as e: pass
else:
    cmdBindVertexBuffers.restype = None
    cmdBindVertexBuffers.argtypes = [ 
        CommandBuffer,
        ctypes.c_uint32,
        ctypes.c_uint32,
        vkbuilder.Pointer(Buffer),
        vkbuilder.Pointer(DeviceSize),
    ]

try:
    cmdDraw = lib.vkCmdDraw
except AttributeError as e: pass
else:
    cmdDraw.restype = None
    cmdDraw.argtypes = [ 
        CommandBuffer,
        ctypes.c_uint32,
        ctypes.c_uint32,
        ctypes.c_uint32,
        ctypes.c_uint32,
    ]

try:
    cmdDrawIndexed = lib.vkCmdDrawIndexed
except AttributeError as e: pass
else:
    cmdDrawIndexed.restype = None
    cmdDrawIndexed.argtypes = [ 
        CommandBuffer,
        ctypes.c_uint32,
        ctypes.c_uint32,
        ctypes.c_uint32,
        ctypes.c_int32,
        ctypes.c_uint32,
    ]

try:
    cmdDrawIndirect = lib.vkCmdDrawIndirect
except AttributeError as e: pass
else:
    cmdDrawIndirect.restype = None
    cmdDrawIndirect.argtypes = [ 
        CommandBuffer,
        Buffer,
        DeviceSize,
        ctypes.c_uint32,
        ctypes.c_uint32,
    ]

try:
    cmdDrawIndexedIndirect = lib.vkCmdDrawIndexedIndirect
except AttributeError as e: pass
else:
    cmdDrawIndexedIndirect.restype = None
    cmdDrawIndexedIndirect.argtypes = [ 
        CommandBuffer,
        Buffer,
        DeviceSize,
        ctypes.c_uint32,
        ctypes.c_uint32,
    ]

try:
    cmdDispatch = lib.vkCmdDispatch
except AttributeError as e: pass
else:
    cmdDispatch.restype = None
    cmdDispatch.argtypes = [ 
        CommandBuffer,
        ctypes.c_uint32,
        ctypes.c_uint32,
        ctypes.c_uint32,
    ]

try:
    cmdDispatchIndirect = lib.vkCmdDispatchIndirect
except AttributeError as e: pass
else:
    cmdDispatchIndirect.restype = None
    cmdDispatchIndirect.argtypes = [ 
        CommandBuffer,
        Buffer,
        DeviceSize,
    ]

try:
    cmdCopyBuffer = lib.vkCmdCopyBuffer
except AttributeError as e: pass
else:
    cmdCopyBuffer.restype = None
    cmdCopyBuffer.argtypes = [ 
        CommandBuffer,
        Buffer,
        Buffer,
        ctypes.c_uint32,
        vkbuilder.Pointer(BufferCopy),
    ]

try:
    cmdCopyImage = lib.vkCmdCopyImage
except AttributeError as e: pass
else:
    cmdCopyImage.restype = None
    cmdCopyImage.argtypes = [ 
        CommandBuffer,
        Image,
        ImageLayout,
        Image,
        ImageLayout,
        ctypes.c_uint32,
        vkbuilder.Pointer(ImageCopy),
    ]

try:
    cmdBlitImage = lib.vkCmdBlitImage
except AttributeError as e: pass
else:
    cmdBlitImage.restype = None
    cmdBlitImage.argtypes = [ 
        CommandBuffer,
        Image,
        ImageLayout,
        Image,
        ImageLayout,
        ctypes.c_uint32,
        vkbuilder.Pointer(ImageBlit),
        Filter,
    ]

try:
    cmdCopyBufferToImage = lib.vkCmdCopyBufferToImage
except AttributeError as e: pass
else:
    cmdCopyBufferToImage.restype = None
    cmdCopyBufferToImage.argtypes = [ 
        CommandBuffer,
        Buffer,
        Image,
        ImageLayout,
        ctypes.c_uint32,
        vkbuilder.Pointer(BufferImageCopy),
    ]

try:
    cmdCopyImageToBuffer = lib.vkCmdCopyImageToBuffer
except AttributeError as e: pass
else:
    cmdCopyImageToBuffer.restype = None
    cmdCopyImageToBuffer.argtypes = [ 
        CommandBuffer,
        Image,
        ImageLayout,
        Buffer,
        ctypes.c_uint32,
        vkbuilder.Pointer(BufferImageCopy),
    ]

try:
    cmdUpdateBuffer = lib.vkCmdUpdateBuffer
except AttributeError as e: pass
else:
    cmdUpdateBuffer.restype = None
    cmdUpdateBuffer.argtypes = [ 
        CommandBuffer,
        Buffer,
        DeviceSize,
        DeviceSize,
        ctypes.c_void_p,
    ]

try:
    cmdFillBuffer = lib.vkCmdFillBuffer
except AttributeError as e: pass
else:
    cmdFillBuffer.restype = None
    cmdFillBuffer.argtypes = [ 
        CommandBuffer,
        Buffer,
        DeviceSize,
        DeviceSize,
        ctypes.c_uint32,
    ]

try:
    cmdClearColorImage = lib.vkCmdClearColorImage
except AttributeError as e: pass
else:
    cmdClearColorImage.restype = None
    cmdClearColorImage.argtypes = [ 
        CommandBuffer,
        Image,
        ImageLayout,
        vkbuilder.Pointer(ClearColorValue),
        ctypes.c_uint32,
        vkbuilder.Pointer(ImageSubresourceRange),
    ]

try:
    cmdClearDepthStencilImage = lib.vkCmdClearDepthStencilImage
except AttributeError as e: pass
else:
    cmdClearDepthStencilImage.restype = None
    cmdClearDepthStencilImage.argtypes = [ 
        CommandBuffer,
        Image,
        ImageLayout,
        vkbuilder.Pointer(ClearDepthStencilValue),
        ctypes.c_uint32,
        vkbuilder.Pointer(ImageSubresourceRange),
    ]

try:
    cmdClearAttachments = lib.vkCmdClearAttachments
except AttributeError as e: pass
else:
    cmdClearAttachments.restype = None
    cmdClearAttachments.argtypes = [ 
        CommandBuffer,
        ctypes.c_uint32,
        vkbuilder.Pointer(ClearAttachment),
        ctypes.c_uint32,
        vkbuilder.Pointer(ClearRect),
    ]

try:
    cmdResolveImage = lib.vkCmdResolveImage
except AttributeError as e: pass
else:
    cmdResolveImage.restype = None
    cmdResolveImage.argtypes = [ 
        CommandBuffer,
        Image,
        ImageLayout,
        Image,
        ImageLayout,
        ctypes.c_uint32,
        vkbuilder.Pointer(ImageResolve),
    ]

try:
    cmdSetEvent = lib.vkCmdSetEvent
except AttributeError as e: pass
else:
    cmdSetEvent.restype = None
    cmdSetEvent.argtypes = [ 
        CommandBuffer,
        Event,
        PipelineStageFlags,
    ]

try:
    cmdResetEvent = lib.vkCmdResetEvent
except AttributeError as e: pass
else:
    cmdResetEvent.restype = None
    cmdResetEvent.argtypes = [ 
        CommandBuffer,
        Event,
        PipelineStageFlags,
    ]

try:
    cmdWaitEvents = lib.vkCmdWaitEvents
except AttributeError as e: pass
else:
    cmdWaitEvents.restype = None
    cmdWaitEvents.argtypes = [ 
        CommandBuffer,
        ctypes.c_uint32,
        vkbuilder.Pointer(Event),
        PipelineStageFlags,
        PipelineStageFlags,
        ctypes.c_uint32,
        vkbuilder.Pointer(MemoryBarrier),
        ctypes.c_uint32,
        vkbuilder.Pointer(BufferMemoryBarrier),
        ctypes.c_uint32,
        vkbuilder.Pointer(ImageMemoryBarrier),
    ]

try:
    cmdPipelineBarrier = lib.vkCmdPipelineBarrier
except AttributeError as e: pass
else:
    cmdPipelineBarrier.restype = None
    cmdPipelineBarrier.argtypes = [ 
        CommandBuffer,
        PipelineStageFlags,
        PipelineStageFlags,
        DependencyFlags,
        ctypes.c_uint32,
        vkbuilder.Pointer(MemoryBarrier),
        ctypes.c_uint32,
        vkbuilder.Pointer(BufferMemoryBarrier),
        ctypes.c_uint32,
        vkbuilder.Pointer(ImageMemoryBarrier),
    ]

try:
    cmdBeginQuery = lib.vkCmdBeginQuery
except AttributeError as e: pass
else:
    cmdBeginQuery.restype = None
    cmdBeginQuery.argtypes = [ 
        CommandBuffer,
        QueryPool,
        ctypes.c_uint32,
        QueryControlFlags,
    ]

try:
    cmdEndQuery = lib.vkCmdEndQuery
except AttributeError as e: pass
else:
    cmdEndQuery.restype = None
    cmdEndQuery.argtypes = [ 
        CommandBuffer,
        QueryPool,
        ctypes.c_uint32,
    ]

try:
    cmdResetQueryPool = lib.vkCmdResetQueryPool
except AttributeError as e: pass
else:
    cmdResetQueryPool.restype = None
    cmdResetQueryPool.argtypes = [ 
        CommandBuffer,
        QueryPool,
        ctypes.c_uint32,
        ctypes.c_uint32,
    ]

try:
    cmdWriteTimestamp = lib.vkCmdWriteTimestamp
except AttributeError as e: pass
else:
    cmdWriteTimestamp.restype = None
    cmdWriteTimestamp.argtypes = [ 
        CommandBuffer,
        PipelineStageFlags,
        QueryPool,
        ctypes.c_uint32,
    ]

try:
    cmdCopyQueryPoolResults = lib.vkCmdCopyQueryPoolResults
except AttributeError as e: pass
else:
    cmdCopyQueryPoolResults.restype = None
    cmdCopyQueryPoolResults.argtypes = [ 
        CommandBuffer,
        QueryPool,
        ctypes.c_uint32,
        ctypes.c_uint32,
        Buffer,
        DeviceSize,
        DeviceSize,
        QueryResultFlags,
    ]

try:
    cmdPushConstants = lib.vkCmdPushConstants
except AttributeError as e: pass
else:
    cmdPushConstants.restype = None
    cmdPushConstants.argtypes = [ 
        CommandBuffer,
        PipelineLayout,
        ShaderStageFlags,
        ctypes.c_uint32,
        ctypes.c_uint32,
        ctypes.c_void_p,
    ]

try:
    cmdBeginRenderPass = lib.vkCmdBeginRenderPass
except AttributeError as e: pass
else:
    cmdBeginRenderPass.restype = None
    cmdBeginRenderPass.argtypes = [ 
        CommandBuffer,
        vkbuilder.Pointer(RenderPassBeginInfo),
        SubpassContents,
    ]

try:
    cmdNextSubpass = lib.vkCmdNextSubpass
except AttributeError as e: pass
else:
    cmdNextSubpass.restype = None
    cmdNextSubpass.argtypes = [ 
        CommandBuffer,
        SubpassContents,
    ]

try:
    cmdEndRenderPass = lib.vkCmdEndRenderPass
except AttributeError as e: pass
else:
    cmdEndRenderPass.restype = None
    cmdEndRenderPass.argtypes = [ 
        CommandBuffer,
    ]

try:
    cmdExecuteCommands = lib.vkCmdExecuteCommands
except AttributeError as e: pass
else:
    cmdExecuteCommands.restype = None
    cmdExecuteCommands.argtypes = [ 
        CommandBuffer,
        ctypes.c_uint32,
        vkbuilder.Pointer(CommandBuffer),
    ]

try:
    createAndroidSurfaceKHR = lib.vkCreateAndroidSurfaceKHR
except AttributeError as e: pass
else:
    createAndroidSurfaceKHR.restype = ResultCheck
    createAndroidSurfaceKHR.argtypes = [ 
        Instance,
        vkbuilder.Pointer(AndroidSurfaceCreateInfoKHR),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(SurfaceKHR),
    ]

try:
    getPhysicalDeviceDisplayPropertiesKHR = lib.vkGetPhysicalDeviceDisplayPropertiesKHR
except AttributeError as e: pass
else:
    getPhysicalDeviceDisplayPropertiesKHR.restype = ResultCheck
    getPhysicalDeviceDisplayPropertiesKHR.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(DisplayPropertiesKHR),
    ]

try:
    getPhysicalDeviceDisplayPlanePropertiesKHR = lib.vkGetPhysicalDeviceDisplayPlanePropertiesKHR
except AttributeError as e: pass
else:
    getPhysicalDeviceDisplayPlanePropertiesKHR.restype = ResultCheck
    getPhysicalDeviceDisplayPlanePropertiesKHR.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(DisplayPlanePropertiesKHR),
    ]

try:
    getDisplayPlaneSupportedDisplaysKHR = lib.vkGetDisplayPlaneSupportedDisplaysKHR
except AttributeError as e: pass
else:
    getDisplayPlaneSupportedDisplaysKHR.restype = ResultCheck
    getDisplayPlaneSupportedDisplaysKHR.argtypes = [ 
        PhysicalDevice,
        ctypes.c_uint32,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(DisplayKHR),
    ]

try:
    getDisplayModePropertiesKHR = lib.vkGetDisplayModePropertiesKHR
except AttributeError as e: pass
else:
    getDisplayModePropertiesKHR.restype = ResultCheck
    getDisplayModePropertiesKHR.argtypes = [ 
        PhysicalDevice,
        DisplayKHR,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(DisplayModePropertiesKHR),
    ]

try:
    createDisplayModeKHR = lib.vkCreateDisplayModeKHR
except AttributeError as e: pass
else:
    createDisplayModeKHR.restype = ResultCheck
    createDisplayModeKHR.argtypes = [ 
        PhysicalDevice,
        DisplayKHR,
        vkbuilder.Pointer(DisplayModeCreateInfoKHR),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(DisplayModeKHR),
    ]

try:
    getDisplayPlaneCapabilitiesKHR = lib.vkGetDisplayPlaneCapabilitiesKHR
except AttributeError as e: pass
else:
    getDisplayPlaneCapabilitiesKHR.restype = ResultCheck
    getDisplayPlaneCapabilitiesKHR.argtypes = [ 
        PhysicalDevice,
        DisplayModeKHR,
        ctypes.c_uint32,
        vkbuilder.Pointer(DisplayPlaneCapabilitiesKHR),
    ]

try:
    createDisplayPlaneSurfaceKHR = lib.vkCreateDisplayPlaneSurfaceKHR
except AttributeError as e: pass
else:
    createDisplayPlaneSurfaceKHR.restype = ResultCheck
    createDisplayPlaneSurfaceKHR.argtypes = [ 
        Instance,
        vkbuilder.Pointer(DisplaySurfaceCreateInfoKHR),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(SurfaceKHR),
    ]

try:
    createSharedSwapchainsKHR = lib.vkCreateSharedSwapchainsKHR
except AttributeError as e: pass
else:
    createSharedSwapchainsKHR.restype = ResultCheck
    createSharedSwapchainsKHR.argtypes = [ 
        Device,
        ctypes.c_uint32,
        vkbuilder.Pointer(SwapchainCreateInfoKHR),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(SwapchainKHR),
    ]

try:
    createMirSurfaceKHR = lib.vkCreateMirSurfaceKHR
except AttributeError as e: pass
else:
    createMirSurfaceKHR.restype = ResultCheck
    createMirSurfaceKHR.argtypes = [ 
        Instance,
        vkbuilder.Pointer(MirSurfaceCreateInfoKHR),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(SurfaceKHR),
    ]

try:
    getPhysicalDeviceMirPresentationSupportKHR = lib.vkGetPhysicalDeviceMirPresentationSupportKHR
except AttributeError as e: pass
else:
    getPhysicalDeviceMirPresentationSupportKHR.restype = Bool32
    getPhysicalDeviceMirPresentationSupportKHR.argtypes = [ 
        PhysicalDevice,
        ctypes.c_uint32,
        vkbuilder.Pointer(ctypes.c_void_p),
    ]

try:
    destroySurfaceKHR = lib.vkDestroySurfaceKHR
except AttributeError as e: pass
else:
    destroySurfaceKHR.restype = None
    destroySurfaceKHR.argtypes = [ 
        Instance,
        SurfaceKHR,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    getPhysicalDeviceSurfaceSupportKHR = lib.vkGetPhysicalDeviceSurfaceSupportKHR
except AttributeError as e: pass
else:
    getPhysicalDeviceSurfaceSupportKHR.restype = ResultCheck
    getPhysicalDeviceSurfaceSupportKHR.argtypes = [ 
        PhysicalDevice,
        ctypes.c_uint32,
        SurfaceKHR,
        vkbuilder.Pointer(Bool32),
    ]

try:
    getPhysicalDeviceSurfaceCapabilitiesKHR = lib.vkGetPhysicalDeviceSurfaceCapabilitiesKHR
except AttributeError as e: pass
else:
    getPhysicalDeviceSurfaceCapabilitiesKHR.restype = ResultCheck
    getPhysicalDeviceSurfaceCapabilitiesKHR.argtypes = [ 
        PhysicalDevice,
        SurfaceKHR,
        vkbuilder.Pointer(SurfaceCapabilitiesKHR),
    ]

try:
    getPhysicalDeviceSurfaceFormatsKHR = lib.vkGetPhysicalDeviceSurfaceFormatsKHR
except AttributeError as e: pass
else:
    getPhysicalDeviceSurfaceFormatsKHR.restype = ResultCheck
    getPhysicalDeviceSurfaceFormatsKHR.argtypes = [ 
        PhysicalDevice,
        SurfaceKHR,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(SurfaceFormatKHR),
    ]

try:
    getPhysicalDeviceSurfacePresentModesKHR = lib.vkGetPhysicalDeviceSurfacePresentModesKHR
except AttributeError as e: pass
else:
    getPhysicalDeviceSurfacePresentModesKHR.restype = ResultCheck
    getPhysicalDeviceSurfacePresentModesKHR.argtypes = [ 
        PhysicalDevice,
        SurfaceKHR,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(PresentModeKHR),
    ]

try:
    createSwapchainKHR = lib.vkCreateSwapchainKHR
except AttributeError as e: pass
else:
    createSwapchainKHR.restype = ResultCheck
    createSwapchainKHR.argtypes = [ 
        Device,
        vkbuilder.Pointer(SwapchainCreateInfoKHR),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(SwapchainKHR),
    ]

try:
    destroySwapchainKHR = lib.vkDestroySwapchainKHR
except AttributeError as e: pass
else:
    destroySwapchainKHR.restype = None
    destroySwapchainKHR.argtypes = [ 
        Device,
        SwapchainKHR,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    getSwapchainImagesKHR = lib.vkGetSwapchainImagesKHR
except AttributeError as e: pass
else:
    getSwapchainImagesKHR.restype = ResultCheck
    getSwapchainImagesKHR.argtypes = [ 
        Device,
        SwapchainKHR,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(Image),
    ]

try:
    acquireNextImageKHR = lib.vkAcquireNextImageKHR
except AttributeError as e: pass
else:
    acquireNextImageKHR.restype = ResultCheck
    acquireNextImageKHR.argtypes = [ 
        Device,
        SwapchainKHR,
        ctypes.c_uint64,
        Semaphore,
        Fence,
        vkbuilder.Pointer(ctypes.c_uint32),
    ]

try:
    queuePresentKHR = lib.vkQueuePresentKHR
except AttributeError as e: pass
else:
    queuePresentKHR.restype = ResultCheck
    queuePresentKHR.argtypes = [ 
        Queue,
        vkbuilder.Pointer(PresentInfoKHR),
    ]

try:
    createViSurfaceNN = lib.vkCreateViSurfaceNN
except AttributeError as e: pass
else:
    createViSurfaceNN.restype = ResultCheck
    createViSurfaceNN.argtypes = [ 
        Instance,
        vkbuilder.Pointer(ViSurfaceCreateInfoNN),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(SurfaceKHR),
    ]

try:
    createWaylandSurfaceKHR = lib.vkCreateWaylandSurfaceKHR
except AttributeError as e: pass
else:
    createWaylandSurfaceKHR.restype = ResultCheck
    createWaylandSurfaceKHR.argtypes = [ 
        Instance,
        vkbuilder.Pointer(WaylandSurfaceCreateInfoKHR),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(SurfaceKHR),
    ]

try:
    getPhysicalDeviceWaylandPresentationSupportKHR = lib.vkGetPhysicalDeviceWaylandPresentationSupportKHR
except AttributeError as e: pass
else:
    getPhysicalDeviceWaylandPresentationSupportKHR.restype = Bool32
    getPhysicalDeviceWaylandPresentationSupportKHR.argtypes = [ 
        PhysicalDevice,
        ctypes.c_uint32,
        ctypes.c_void_p,
    ]

try:
    createWin32SurfaceKHR = lib.vkCreateWin32SurfaceKHR
except AttributeError as e: pass
else:
    createWin32SurfaceKHR.restype = ResultCheck
    createWin32SurfaceKHR.argtypes = [ 
        Instance,
        vkbuilder.Pointer(Win32SurfaceCreateInfoKHR),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(SurfaceKHR),
    ]

try:
    getPhysicalDeviceWin32PresentationSupportKHR = lib.vkGetPhysicalDeviceWin32PresentationSupportKHR
except AttributeError as e: pass
else:
    getPhysicalDeviceWin32PresentationSupportKHR.restype = Bool32
    getPhysicalDeviceWin32PresentationSupportKHR.argtypes = [ 
        PhysicalDevice,
        ctypes.c_uint32,
    ]

try:
    createXlibSurfaceKHR = lib.vkCreateXlibSurfaceKHR
except AttributeError as e: pass
else:
    createXlibSurfaceKHR.restype = ResultCheck
    createXlibSurfaceKHR.argtypes = [ 
        Instance,
        vkbuilder.Pointer(XlibSurfaceCreateInfoKHR),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(SurfaceKHR),
    ]

try:
    getPhysicalDeviceXlibPresentationSupportKHR = lib.vkGetPhysicalDeviceXlibPresentationSupportKHR
except AttributeError as e: pass
else:
    getPhysicalDeviceXlibPresentationSupportKHR.restype = Bool32
    getPhysicalDeviceXlibPresentationSupportKHR.argtypes = [ 
        PhysicalDevice,
        ctypes.c_uint32,
        vkbuilder.Pointer(ctypes.c_void_p),
        ctypes.c_void_p,
    ]

try:
    createXcbSurfaceKHR = lib.vkCreateXcbSurfaceKHR
except AttributeError as e: pass
else:
    createXcbSurfaceKHR.restype = ResultCheck
    createXcbSurfaceKHR.argtypes = [ 
        Instance,
        vkbuilder.Pointer(XcbSurfaceCreateInfoKHR),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(SurfaceKHR),
    ]

try:
    getPhysicalDeviceXcbPresentationSupportKHR = lib.vkGetPhysicalDeviceXcbPresentationSupportKHR
except AttributeError as e: pass
else:
    getPhysicalDeviceXcbPresentationSupportKHR.restype = Bool32
    getPhysicalDeviceXcbPresentationSupportKHR.argtypes = [ 
        PhysicalDevice,
        ctypes.c_uint32,
        ctypes.c_void_p,
        ctypes.c_void_p,
    ]

try:
    createDebugReportCallbackEXT = lib.vkCreateDebugReportCallbackEXT
except AttributeError as e: pass
else:
    createDebugReportCallbackEXT.restype = ResultCheck
    createDebugReportCallbackEXT.argtypes = [ 
        Instance,
        vkbuilder.Pointer(DebugReportCallbackCreateInfoEXT),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(DebugReportCallbackEXT),
    ]

try:
    destroyDebugReportCallbackEXT = lib.vkDestroyDebugReportCallbackEXT
except AttributeError as e: pass
else:
    destroyDebugReportCallbackEXT.restype = None
    destroyDebugReportCallbackEXT.argtypes = [ 
        Instance,
        DebugReportCallbackEXT,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    debugReportMessageEXT = lib.vkDebugReportMessageEXT
except AttributeError as e: pass
else:
    debugReportMessageEXT.restype = None
    debugReportMessageEXT.argtypes = [ 
        Instance,
        DebugReportFlagsEXT,
        DebugReportObjectTypeEXT,
        ctypes.c_uint64,
        ctypes.c_size_t,
        ctypes.c_int32,
        ctypes.c_char_p,
        ctypes.c_char_p,
    ]

try:
    debugMarkerSetObjectNameEXT = lib.vkDebugMarkerSetObjectNameEXT
except AttributeError as e: pass
else:
    debugMarkerSetObjectNameEXT.restype = ResultCheck
    debugMarkerSetObjectNameEXT.argtypes = [ 
        Device,
        vkbuilder.Pointer(DebugMarkerObjectNameInfoEXT),
    ]

try:
    debugMarkerSetObjectTagEXT = lib.vkDebugMarkerSetObjectTagEXT
except AttributeError as e: pass
else:
    debugMarkerSetObjectTagEXT.restype = ResultCheck
    debugMarkerSetObjectTagEXT.argtypes = [ 
        Device,
        vkbuilder.Pointer(DebugMarkerObjectTagInfoEXT),
    ]

try:
    cmdDebugMarkerBeginEXT = lib.vkCmdDebugMarkerBeginEXT
except AttributeError as e: pass
else:
    cmdDebugMarkerBeginEXT.restype = None
    cmdDebugMarkerBeginEXT.argtypes = [ 
        CommandBuffer,
        vkbuilder.Pointer(DebugMarkerMarkerInfoEXT),
    ]

try:
    cmdDebugMarkerEndEXT = lib.vkCmdDebugMarkerEndEXT
except AttributeError as e: pass
else:
    cmdDebugMarkerEndEXT.restype = None
    cmdDebugMarkerEndEXT.argtypes = [ 
        CommandBuffer,
    ]

try:
    cmdDebugMarkerInsertEXT = lib.vkCmdDebugMarkerInsertEXT
except AttributeError as e: pass
else:
    cmdDebugMarkerInsertEXT.restype = None
    cmdDebugMarkerInsertEXT.argtypes = [ 
        CommandBuffer,
        vkbuilder.Pointer(DebugMarkerMarkerInfoEXT),
    ]

try:
    getPhysicalDeviceExternalImageFormatPropertiesNV = lib.vkGetPhysicalDeviceExternalImageFormatPropertiesNV
except AttributeError as e: pass
else:
    getPhysicalDeviceExternalImageFormatPropertiesNV.restype = ResultCheck
    getPhysicalDeviceExternalImageFormatPropertiesNV.argtypes = [ 
        PhysicalDevice,
        Format,
        ImageType,
        ImageTiling,
        ImageUsageFlags,
        ImageCreateFlags,
        ExternalMemoryHandleTypeFlagsNV,
        vkbuilder.Pointer(ExternalImageFormatPropertiesNV),
    ]

try:
    getMemoryWin32HandleNV = lib.vkGetMemoryWin32HandleNV
except AttributeError as e: pass
else:
    getMemoryWin32HandleNV.restype = ResultCheck
    getMemoryWin32HandleNV.argtypes = [ 
        Device,
        DeviceMemory,
        ExternalMemoryHandleTypeFlagsNV,
        vkbuilder.Pointer(ctypes.c_void_p),
    ]

try:
    cmdDrawIndirectCountAMD = lib.vkCmdDrawIndirectCountAMD
except AttributeError as e: pass
else:
    cmdDrawIndirectCountAMD.restype = None
    cmdDrawIndirectCountAMD.argtypes = [ 
        CommandBuffer,
        Buffer,
        DeviceSize,
        Buffer,
        DeviceSize,
        ctypes.c_uint32,
        ctypes.c_uint32,
    ]

try:
    cmdDrawIndexedIndirectCountAMD = lib.vkCmdDrawIndexedIndirectCountAMD
except AttributeError as e: pass
else:
    cmdDrawIndexedIndirectCountAMD.restype = None
    cmdDrawIndexedIndirectCountAMD.argtypes = [ 
        CommandBuffer,
        Buffer,
        DeviceSize,
        Buffer,
        DeviceSize,
        ctypes.c_uint32,
        ctypes.c_uint32,
    ]

try:
    cmdProcessCommandsNVX = lib.vkCmdProcessCommandsNVX
except AttributeError as e: pass
else:
    cmdProcessCommandsNVX.restype = None
    cmdProcessCommandsNVX.argtypes = [ 
        CommandBuffer,
        vkbuilder.Pointer(CmdProcessCommandsInfoNVX),
    ]

try:
    cmdReserveSpaceForCommandsNVX = lib.vkCmdReserveSpaceForCommandsNVX
except AttributeError as e: pass
else:
    cmdReserveSpaceForCommandsNVX.restype = None
    cmdReserveSpaceForCommandsNVX.argtypes = [ 
        CommandBuffer,
        vkbuilder.Pointer(CmdReserveSpaceForCommandsInfoNVX),
    ]

try:
    createIndirectCommandsLayoutNVX = lib.vkCreateIndirectCommandsLayoutNVX
except AttributeError as e: pass
else:
    createIndirectCommandsLayoutNVX.restype = ResultCheck
    createIndirectCommandsLayoutNVX.argtypes = [ 
        Device,
        vkbuilder.Pointer(IndirectCommandsLayoutCreateInfoNVX),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(IndirectCommandsLayoutNVX),
    ]

try:
    destroyIndirectCommandsLayoutNVX = lib.vkDestroyIndirectCommandsLayoutNVX
except AttributeError as e: pass
else:
    destroyIndirectCommandsLayoutNVX.restype = None
    destroyIndirectCommandsLayoutNVX.argtypes = [ 
        Device,
        IndirectCommandsLayoutNVX,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    createObjectTableNVX = lib.vkCreateObjectTableNVX
except AttributeError as e: pass
else:
    createObjectTableNVX.restype = ResultCheck
    createObjectTableNVX.argtypes = [ 
        Device,
        vkbuilder.Pointer(ObjectTableCreateInfoNVX),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(ObjectTableNVX),
    ]

try:
    destroyObjectTableNVX = lib.vkDestroyObjectTableNVX
except AttributeError as e: pass
else:
    destroyObjectTableNVX.restype = None
    destroyObjectTableNVX.argtypes = [ 
        Device,
        ObjectTableNVX,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    registerObjectsNVX = lib.vkRegisterObjectsNVX
except AttributeError as e: pass
else:
    registerObjectsNVX.restype = ResultCheck
    registerObjectsNVX.argtypes = [ 
        Device,
        ObjectTableNVX,
        ctypes.c_uint32,
        vkbuilder.Pointer(vkbuilder.Pointer(ObjectTableEntryNVX)),
        vkbuilder.Pointer(ctypes.c_uint32),
    ]

try:
    unregisterObjectsNVX = lib.vkUnregisterObjectsNVX
except AttributeError as e: pass
else:
    unregisterObjectsNVX.restype = ResultCheck
    unregisterObjectsNVX.argtypes = [ 
        Device,
        ObjectTableNVX,
        ctypes.c_uint32,
        vkbuilder.Pointer(ObjectEntryTypeNVX),
        vkbuilder.Pointer(ctypes.c_uint32),
    ]

try:
    getPhysicalDeviceGeneratedCommandsPropertiesNVX = lib.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX
except AttributeError as e: pass
else:
    getPhysicalDeviceGeneratedCommandsPropertiesNVX.restype = None
    getPhysicalDeviceGeneratedCommandsPropertiesNVX.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(DeviceGeneratedCommandsFeaturesNVX),
        vkbuilder.Pointer(DeviceGeneratedCommandsLimitsNVX),
    ]

try:
    getPhysicalDeviceFeatures2KHR = lib.vkGetPhysicalDeviceFeatures2KHR
except AttributeError as e: pass
else:
    getPhysicalDeviceFeatures2KHR.restype = None
    getPhysicalDeviceFeatures2KHR.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(PhysicalDeviceFeatures2KHR),
    ]

try:
    getPhysicalDeviceProperties2KHR = lib.vkGetPhysicalDeviceProperties2KHR
except AttributeError as e: pass
else:
    getPhysicalDeviceProperties2KHR.restype = None
    getPhysicalDeviceProperties2KHR.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(PhysicalDeviceProperties2KHR),
    ]

try:
    getPhysicalDeviceFormatProperties2KHR = lib.vkGetPhysicalDeviceFormatProperties2KHR
except AttributeError as e: pass
else:
    getPhysicalDeviceFormatProperties2KHR.restype = None
    getPhysicalDeviceFormatProperties2KHR.argtypes = [ 
        PhysicalDevice,
        Format,
        vkbuilder.Pointer(FormatProperties2KHR),
    ]

try:
    getPhysicalDeviceImageFormatProperties2KHR = lib.vkGetPhysicalDeviceImageFormatProperties2KHR
except AttributeError as e: pass
else:
    getPhysicalDeviceImageFormatProperties2KHR.restype = ResultCheck
    getPhysicalDeviceImageFormatProperties2KHR.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(PhysicalDeviceImageFormatInfo2KHR),
        vkbuilder.Pointer(ImageFormatProperties2KHR),
    ]

try:
    getPhysicalDeviceQueueFamilyProperties2KHR = lib.vkGetPhysicalDeviceQueueFamilyProperties2KHR
except AttributeError as e: pass
else:
    getPhysicalDeviceQueueFamilyProperties2KHR.restype = None
    getPhysicalDeviceQueueFamilyProperties2KHR.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(QueueFamilyProperties2KHR),
    ]

try:
    getPhysicalDeviceMemoryProperties2KHR = lib.vkGetPhysicalDeviceMemoryProperties2KHR
except AttributeError as e: pass
else:
    getPhysicalDeviceMemoryProperties2KHR.restype = None
    getPhysicalDeviceMemoryProperties2KHR.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(PhysicalDeviceMemoryProperties2KHR),
    ]

try:
    getPhysicalDeviceSparseImageFormatProperties2KHR = lib.vkGetPhysicalDeviceSparseImageFormatProperties2KHR
except AttributeError as e: pass
else:
    getPhysicalDeviceSparseImageFormatProperties2KHR.restype = None
    getPhysicalDeviceSparseImageFormatProperties2KHR.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(PhysicalDeviceSparseImageFormatInfo2KHR),
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(SparseImageFormatProperties2KHR),
    ]

try:
    cmdPushDescriptorSetKHR = lib.vkCmdPushDescriptorSetKHR
except AttributeError as e: pass
else:
    cmdPushDescriptorSetKHR.restype = None
    cmdPushDescriptorSetKHR.argtypes = [ 
        CommandBuffer,
        PipelineBindPoint,
        PipelineLayout,
        ctypes.c_uint32,
        ctypes.c_uint32,
        vkbuilder.Pointer(WriteDescriptorSet),
    ]

try:
    trimCommandPoolKHR = lib.vkTrimCommandPoolKHR
except AttributeError as e: pass
else:
    trimCommandPoolKHR.restype = None
    trimCommandPoolKHR.argtypes = [ 
        Device,
        CommandPool,
        CommandPoolTrimFlagsKHR,
    ]

try:
    getPhysicalDeviceExternalBufferPropertiesKHX = lib.vkGetPhysicalDeviceExternalBufferPropertiesKHX
except AttributeError as e: pass
else:
    getPhysicalDeviceExternalBufferPropertiesKHX.restype = None
    getPhysicalDeviceExternalBufferPropertiesKHX.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(PhysicalDeviceExternalBufferInfoKHX),
        vkbuilder.Pointer(ExternalBufferPropertiesKHX),
    ]

try:
    getMemoryWin32HandleKHX = lib.vkGetMemoryWin32HandleKHX
except AttributeError as e: pass
else:
    getMemoryWin32HandleKHX.restype = ResultCheck
    getMemoryWin32HandleKHX.argtypes = [ 
        Device,
        DeviceMemory,
        ExternalMemoryHandleTypeFlagsKHX,
        vkbuilder.Pointer(ctypes.c_void_p),
    ]

try:
    getMemoryWin32HandlePropertiesKHX = lib.vkGetMemoryWin32HandlePropertiesKHX
except AttributeError as e: pass
else:
    getMemoryWin32HandlePropertiesKHX.restype = ResultCheck
    getMemoryWin32HandlePropertiesKHX.argtypes = [ 
        Device,
        ExternalMemoryHandleTypeFlagsKHX,
        ctypes.c_void_p,
        vkbuilder.Pointer(MemoryWin32HandlePropertiesKHX),
    ]

try:
    getMemoryFdKHX = lib.vkGetMemoryFdKHX
except AttributeError as e: pass
else:
    getMemoryFdKHX.restype = ResultCheck
    getMemoryFdKHX.argtypes = [ 
        Device,
        DeviceMemory,
        ExternalMemoryHandleTypeFlagsKHX,
        vkbuilder.Pointer(ctypes.c_int),
    ]

try:
    getMemoryFdPropertiesKHX = lib.vkGetMemoryFdPropertiesKHX
except AttributeError as e: pass
else:
    getMemoryFdPropertiesKHX.restype = ResultCheck
    getMemoryFdPropertiesKHX.argtypes = [ 
        Device,
        ExternalMemoryHandleTypeFlagsKHX,
        ctypes.c_int,
        vkbuilder.Pointer(MemoryFdPropertiesKHX),
    ]

try:
    getPhysicalDeviceExternalSemaphorePropertiesKHX = lib.vkGetPhysicalDeviceExternalSemaphorePropertiesKHX
except AttributeError as e: pass
else:
    getPhysicalDeviceExternalSemaphorePropertiesKHX.restype = None
    getPhysicalDeviceExternalSemaphorePropertiesKHX.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(PhysicalDeviceExternalSemaphoreInfoKHX),
        vkbuilder.Pointer(ExternalSemaphorePropertiesKHX),
    ]

try:
    getSemaphoreWin32HandleKHX = lib.vkGetSemaphoreWin32HandleKHX
except AttributeError as e: pass
else:
    getSemaphoreWin32HandleKHX.restype = ResultCheck
    getSemaphoreWin32HandleKHX.argtypes = [ 
        Device,
        Semaphore,
        ExternalSemaphoreHandleTypeFlagsKHX,
        vkbuilder.Pointer(ctypes.c_void_p),
    ]

try:
    importSemaphoreWin32HandleKHX = lib.vkImportSemaphoreWin32HandleKHX
except AttributeError as e: pass
else:
    importSemaphoreWin32HandleKHX.restype = ResultCheck
    importSemaphoreWin32HandleKHX.argtypes = [ 
        Device,
        vkbuilder.Pointer(ImportSemaphoreWin32HandleInfoKHX),
    ]

try:
    getSemaphoreFdKHX = lib.vkGetSemaphoreFdKHX
except AttributeError as e: pass
else:
    getSemaphoreFdKHX.restype = ResultCheck
    getSemaphoreFdKHX.argtypes = [ 
        Device,
        Semaphore,
        ExternalSemaphoreHandleTypeFlagsKHX,
        vkbuilder.Pointer(ctypes.c_int),
    ]

try:
    importSemaphoreFdKHX = lib.vkImportSemaphoreFdKHX
except AttributeError as e: pass
else:
    importSemaphoreFdKHX.restype = ResultCheck
    importSemaphoreFdKHX.argtypes = [ 
        Device,
        vkbuilder.Pointer(ImportSemaphoreFdInfoKHX),
    ]

try:
    releaseDisplayEXT = lib.vkReleaseDisplayEXT
except AttributeError as e: pass
else:
    releaseDisplayEXT.restype = ResultCheck
    releaseDisplayEXT.argtypes = [ 
        PhysicalDevice,
        DisplayKHR,
    ]

try:
    acquireXlibDisplayEXT = lib.vkAcquireXlibDisplayEXT
except AttributeError as e: pass
else:
    acquireXlibDisplayEXT.restype = ResultCheck
    acquireXlibDisplayEXT.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(ctypes.c_void_p),
        DisplayKHR,
    ]

try:
    getRandROutputDisplayEXT = lib.vkGetRandROutputDisplayEXT
except AttributeError as e: pass
else:
    getRandROutputDisplayEXT.restype = ResultCheck
    getRandROutputDisplayEXT.argtypes = [ 
        PhysicalDevice,
        vkbuilder.Pointer(ctypes.c_void_p),
        None,
        vkbuilder.Pointer(DisplayKHR),
    ]

try:
    displayPowerControlEXT = lib.vkDisplayPowerControlEXT
except AttributeError as e: pass
else:
    displayPowerControlEXT.restype = ResultCheck
    displayPowerControlEXT.argtypes = [ 
        Device,
        DisplayKHR,
        vkbuilder.Pointer(DisplayPowerInfoEXT),
    ]

try:
    registerDeviceEventEXT = lib.vkRegisterDeviceEventEXT
except AttributeError as e: pass
else:
    registerDeviceEventEXT.restype = ResultCheck
    registerDeviceEventEXT.argtypes = [ 
        Device,
        vkbuilder.Pointer(DeviceEventInfoEXT),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(Fence),
    ]

try:
    registerDisplayEventEXT = lib.vkRegisterDisplayEventEXT
except AttributeError as e: pass
else:
    registerDisplayEventEXT.restype = ResultCheck
    registerDisplayEventEXT.argtypes = [ 
        Device,
        DisplayKHR,
        vkbuilder.Pointer(DisplayEventInfoEXT),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(Fence),
    ]

try:
    getSwapchainCounterEXT = lib.vkGetSwapchainCounterEXT
except AttributeError as e: pass
else:
    getSwapchainCounterEXT.restype = ResultCheck
    getSwapchainCounterEXT.argtypes = [ 
        Device,
        SwapchainKHR,
        SurfaceCounterFlagsEXT,
        vkbuilder.Pointer(ctypes.c_uint64),
    ]

try:
    getPhysicalDeviceSurfaceCapabilities2EXT = lib.vkGetPhysicalDeviceSurfaceCapabilities2EXT
except AttributeError as e: pass
else:
    getPhysicalDeviceSurfaceCapabilities2EXT.restype = ResultCheck
    getPhysicalDeviceSurfaceCapabilities2EXT.argtypes = [ 
        PhysicalDevice,
        SurfaceKHR,
        vkbuilder.Pointer(SurfaceCapabilities2EXT),
    ]

try:
    enumeratePhysicalDeviceGroupsKHX = lib.vkEnumeratePhysicalDeviceGroupsKHX
except AttributeError as e: pass
else:
    enumeratePhysicalDeviceGroupsKHX.restype = ResultCheck
    enumeratePhysicalDeviceGroupsKHX.argtypes = [ 
        Instance,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(PhysicalDeviceGroupPropertiesKHX),
    ]

try:
    getDeviceGroupPeerMemoryFeaturesKHX = lib.vkGetDeviceGroupPeerMemoryFeaturesKHX
except AttributeError as e: pass
else:
    getDeviceGroupPeerMemoryFeaturesKHX.restype = None
    getDeviceGroupPeerMemoryFeaturesKHX.argtypes = [ 
        Device,
        ctypes.c_uint32,
        ctypes.c_uint32,
        ctypes.c_uint32,
        vkbuilder.Pointer(PeerMemoryFeatureFlagsKHX),
    ]

try:
    bindBufferMemory2KHX = lib.vkBindBufferMemory2KHX
except AttributeError as e: pass
else:
    bindBufferMemory2KHX.restype = ResultCheck
    bindBufferMemory2KHX.argtypes = [ 
        Device,
        ctypes.c_uint32,
        vkbuilder.Pointer(BindBufferMemoryInfoKHX),
    ]

try:
    bindImageMemory2KHX = lib.vkBindImageMemory2KHX
except AttributeError as e: pass
else:
    bindImageMemory2KHX.restype = ResultCheck
    bindImageMemory2KHX.argtypes = [ 
        Device,
        ctypes.c_uint32,
        vkbuilder.Pointer(BindImageMemoryInfoKHX),
    ]

try:
    cmdSetDeviceMaskKHX = lib.vkCmdSetDeviceMaskKHX
except AttributeError as e: pass
else:
    cmdSetDeviceMaskKHX.restype = None
    cmdSetDeviceMaskKHX.argtypes = [ 
        CommandBuffer,
        ctypes.c_uint32,
    ]

try:
    getDeviceGroupPresentCapabilitiesKHX = lib.vkGetDeviceGroupPresentCapabilitiesKHX
except AttributeError as e: pass
else:
    getDeviceGroupPresentCapabilitiesKHX.restype = ResultCheck
    getDeviceGroupPresentCapabilitiesKHX.argtypes = [ 
        Device,
        vkbuilder.Pointer(DeviceGroupPresentCapabilitiesKHX),
    ]

try:
    getDeviceGroupSurfacePresentModesKHX = lib.vkGetDeviceGroupSurfacePresentModesKHX
except AttributeError as e: pass
else:
    getDeviceGroupSurfacePresentModesKHX.restype = ResultCheck
    getDeviceGroupSurfacePresentModesKHX.argtypes = [ 
        Device,
        SurfaceKHR,
        vkbuilder.Pointer(DeviceGroupPresentModeFlagsKHX),
    ]

try:
    acquireNextImage2KHX = lib.vkAcquireNextImage2KHX
except AttributeError as e: pass
else:
    acquireNextImage2KHX.restype = ResultCheck
    acquireNextImage2KHX.argtypes = [ 
        Device,
        vkbuilder.Pointer(AcquireNextImageInfoKHX),
        vkbuilder.Pointer(ctypes.c_uint32),
    ]

try:
    cmdDispatchBaseKHX = lib.vkCmdDispatchBaseKHX
except AttributeError as e: pass
else:
    cmdDispatchBaseKHX.restype = None
    cmdDispatchBaseKHX.argtypes = [ 
        CommandBuffer,
        ctypes.c_uint32,
        ctypes.c_uint32,
        ctypes.c_uint32,
        ctypes.c_uint32,
        ctypes.c_uint32,
        ctypes.c_uint32,
    ]

try:
    getPhysicalDevicePresentRectanglesKHX = lib.vkGetPhysicalDevicePresentRectanglesKHX
except AttributeError as e: pass
else:
    getPhysicalDevicePresentRectanglesKHX.restype = ResultCheck
    getPhysicalDevicePresentRectanglesKHX.argtypes = [ 
        PhysicalDevice,
        SurfaceKHR,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(Rect2D),
    ]

try:
    createDescriptorUpdateTemplateKHR = lib.vkCreateDescriptorUpdateTemplateKHR
except AttributeError as e: pass
else:
    createDescriptorUpdateTemplateKHR.restype = ResultCheck
    createDescriptorUpdateTemplateKHR.argtypes = [ 
        Device,
        vkbuilder.Pointer(DescriptorUpdateTemplateCreateInfoKHR),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(DescriptorUpdateTemplateKHR),
    ]

try:
    destroyDescriptorUpdateTemplateKHR = lib.vkDestroyDescriptorUpdateTemplateKHR
except AttributeError as e: pass
else:
    destroyDescriptorUpdateTemplateKHR.restype = None
    destroyDescriptorUpdateTemplateKHR.argtypes = [ 
        Device,
        DescriptorUpdateTemplateKHR,
        vkbuilder.Pointer(AllocationCallbacks),
    ]

try:
    updateDescriptorSetWithTemplateKHR = lib.vkUpdateDescriptorSetWithTemplateKHR
except AttributeError as e: pass
else:
    updateDescriptorSetWithTemplateKHR.restype = None
    updateDescriptorSetWithTemplateKHR.argtypes = [ 
        Device,
        DescriptorSet,
        DescriptorUpdateTemplateKHR,
        ctypes.c_void_p,
    ]

try:
    cmdPushDescriptorSetWithTemplateKHR = lib.vkCmdPushDescriptorSetWithTemplateKHR
except AttributeError as e: pass
else:
    cmdPushDescriptorSetWithTemplateKHR.restype = None
    cmdPushDescriptorSetWithTemplateKHR.argtypes = [ 
        CommandBuffer,
        DescriptorUpdateTemplateKHR,
        PipelineLayout,
        ctypes.c_uint32,
        ctypes.c_void_p,
    ]

try:
    setHdrMetadataEXT = lib.vkSetHdrMetadataEXT
except AttributeError as e: pass
else:
    setHdrMetadataEXT.restype = None
    setHdrMetadataEXT.argtypes = [ 
        Device,
        ctypes.c_uint32,
        vkbuilder.Pointer(SwapchainKHR),
        vkbuilder.Pointer(HdrMetadataEXT),
    ]

try:
    getRefreshCycleDurationGOOGLE = lib.vkGetRefreshCycleDurationGOOGLE
except AttributeError as e: pass
else:
    getRefreshCycleDurationGOOGLE.restype = ResultCheck
    getRefreshCycleDurationGOOGLE.argtypes = [ 
        Device,
        SwapchainKHR,
        vkbuilder.Pointer(RefreshCycleDurationGOOGLE),
    ]

try:
    getPastPresentationTimingGOOGLE = lib.vkGetPastPresentationTimingGOOGLE
except AttributeError as e: pass
else:
    getPastPresentationTimingGOOGLE.restype = ResultCheck
    getPastPresentationTimingGOOGLE.argtypes = [ 
        Device,
        SwapchainKHR,
        vkbuilder.Pointer(ctypes.c_uint32),
        vkbuilder.Pointer(PastPresentationTimingGOOGLE),
    ]

try:
    createIOSSurfaceMVK = lib.vkCreateIOSSurfaceMVK
except AttributeError as e: pass
else:
    createIOSSurfaceMVK.restype = ResultCheck
    createIOSSurfaceMVK.argtypes = [ 
        Instance,
        vkbuilder.Pointer(IOSSurfaceCreateInfoMVK),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(SurfaceKHR),
    ]

try:
    createMacOSSurfaceMVK = lib.vkCreateMacOSSurfaceMVK
except AttributeError as e: pass
else:
    createMacOSSurfaceMVK.restype = ResultCheck
    createMacOSSurfaceMVK.argtypes = [ 
        Instance,
        vkbuilder.Pointer(MacOSSurfaceCreateInfoMVK),
        vkbuilder.Pointer(AllocationCallbacks),
        vkbuilder.Pointer(SurfaceKHR),
    ]

try:
    cmdSetViewportWScalingNV = lib.vkCmdSetViewportWScalingNV
except AttributeError as e: pass
else:
    cmdSetViewportWScalingNV.restype = None
    cmdSetViewportWScalingNV.argtypes = [ 
        CommandBuffer,
        ctypes.c_uint32,
        ctypes.c_uint32,
        vkbuilder.Pointer(ViewportWScalingNV),
    ]

try:
    cmdSetDiscardRectangleEXT = lib.vkCmdSetDiscardRectangleEXT
except AttributeError as e: pass
else:
    cmdSetDiscardRectangleEXT.restype = None
    cmdSetDiscardRectangleEXT.argtypes = [ 
        CommandBuffer,
        ctypes.c_uint32,
        ctypes.c_uint32,
        vkbuilder.Pointer(Rect2D),
    ]