virtio/venus-protocol/vn_protocol_driver_types.h

/* This file is generated by venus-protocol.  See vn_protocol_driver.h. */

/*
 * Copyright 2020 Google LLC
 * SPDX-License-Identifier: MIT
 */

#ifndef VN_PROTOCOL_DRIVER_TYPES_H
#define VN_PROTOCOL_DRIVER_TYPES_H

#include "vn_protocol_driver_defines.h"

/* uint64_t */

static inline size_t
vn_sizeof_uint64_t(const uint64_t *val)
{
    assert(sizeof(*val) == 8);
    return 8;
}

static inline void
vn_encode_uint64_t(struct vn_cs_encoder *enc, const uint64_t *val)
{
    vn_encode(enc, 8, val, sizeof(*val));
}

static inline void
vn_decode_uint64_t(struct vn_cs_decoder *dec, uint64_t *val)
{
    vn_decode(dec, 8, val, sizeof(*val));
}

static inline size_t
vn_sizeof_uint64_t_array(const uint64_t *val, uint32_t count)
{
    assert(sizeof(*val) == 8);
    const size_t size = sizeof(*val) * count;
    assert(size >= count);
    return size;
}

static inline void
vn_encode_uint64_t_array(struct vn_cs_encoder *enc, const uint64_t *val, uint32_t count)
{
    const size_t size = sizeof(*val) * count;
    assert(size >= count);
    vn_encode(enc, size, val, size);
}

static inline void
vn_decode_uint64_t_array(struct vn_cs_decoder *dec, uint64_t *val, uint32_t count)
{
    const size_t size = sizeof(*val) * count;
    assert(size >= count);
    vn_decode(dec, size, val, size);
}

/* int32_t */

static inline size_t
vn_sizeof_int32_t(const int32_t *val)
{
    assert(sizeof(*val) == 4);
    return 4;
}

static inline void
vn_encode_int32_t(struct vn_cs_encoder *enc, const int32_t *val)
{
    vn_encode(enc, 4, val, sizeof(*val));
}

static inline void
vn_decode_int32_t(struct vn_cs_decoder *dec, int32_t *val)
{
    vn_decode(dec, 4, val, sizeof(*val));
}

static inline size_t
vn_sizeof_int32_t_array(const int32_t *val, uint32_t count)
{
    assert(sizeof(*val) == 4);
    const size_t size = sizeof(*val) * count;
    assert(size >= count);
    return size;
}

static inline void
vn_encode_int32_t_array(struct vn_cs_encoder *enc, const int32_t *val, uint32_t count)
{
    const size_t size = sizeof(*val) * count;
    assert(size >= count);
    vn_encode(enc, size, val, size);
}

static inline void
vn_decode_int32_t_array(struct vn_cs_decoder *dec, int32_t *val, uint32_t count)
{
    const size_t size = sizeof(*val) * count;
    assert(size >= count);
    vn_decode(dec, size, val, size);
}

/* enum VkStructureType */

static inline size_t
vn_sizeof_VkStructureType(const VkStructureType *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkStructureType(struct vn_cs_encoder *enc, const VkStructureType *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkStructureType(struct vn_cs_decoder *dec, VkStructureType *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* size_t */

static inline size_t
vn_sizeof_size_t(const size_t *val)
{
    return vn_sizeof_uint64_t(&(uint64_t){ *val });
}

static inline void
vn_encode_size_t(struct vn_cs_encoder *enc, const size_t *val)
{
    const uint64_t tmp = *val;
    vn_encode_uint64_t(enc, &tmp);
}

static inline void
vn_decode_size_t(struct vn_cs_decoder *dec, size_t *val)
{
    uint64_t tmp;
    vn_decode_uint64_t(dec, &tmp);
    *val = tmp;
}

static inline size_t
vn_sizeof_size_t_array(const size_t *val, uint32_t count)
{
    return vn_sizeof_size_t(val) * count;
}

static inline void
vn_encode_size_t_array(struct vn_cs_encoder *enc, const size_t *val, uint32_t count)
{
    if (sizeof(size_t) == sizeof(uint64_t)) {
        vn_encode_uint64_t_array(enc, (const uint64_t *)val, count);
    } else {
        for (uint32_t i = 0; i < count; i++)
            vn_encode_size_t(enc, &val[i]);
    }
}

static inline void
vn_decode_size_t_array(struct vn_cs_decoder *dec, size_t *val, uint32_t count)
{
    if (sizeof(size_t) == sizeof(uint64_t)) {
        vn_decode_uint64_t_array(dec, (uint64_t *)val, count);
    } else {
        for (uint32_t i = 0; i < count; i++)
            vn_decode_size_t(dec, &val[i]);
    }
}

/* opaque blob */

static inline size_t
vn_sizeof_blob_array(const void *val, size_t size)
{
    return (size + 3) & ~3;
}

static inline void
vn_encode_blob_array(struct vn_cs_encoder *enc, const void *val, size_t size)
{
    vn_encode(enc, (size + 3) & ~3, val, size);
}

static inline void
vn_decode_blob_array(struct vn_cs_decoder *dec, void *val, size_t size)
{
    vn_decode(dec, (size + 3) & ~3, val, size);
}

/* string */

static inline size_t
vn_sizeof_char_array(const char *val, size_t size)
{
    return vn_sizeof_blob_array(val, size);
}

static inline void
vn_encode_char_array(struct vn_cs_encoder *enc, const char *val, size_t size)
{
    assert(size && strlen(val) < size);
    vn_encode_blob_array(enc, val, size);
}

static inline void
vn_decode_char_array(struct vn_cs_decoder *dec, char *val, size_t size)
{
    vn_decode_blob_array(dec, val, size);
    if (size)
        val[size - 1] = '\0';
    else
        vn_cs_decoder_set_fatal(dec);
}

/* array size (uint64_t) */

static inline size_t
vn_sizeof_array_size(uint64_t size)
{
    return vn_sizeof_uint64_t(&size);
}

static inline void
vn_encode_array_size(struct vn_cs_encoder *enc, uint64_t size)
{
    vn_encode_uint64_t(enc, &size);
}

static inline uint64_t
vn_decode_array_size(struct vn_cs_decoder *dec, uint64_t expected_size)
{
    uint64_t size;
    vn_decode_uint64_t(dec, &size);
    if (size != expected_size) {
        vn_cs_decoder_set_fatal(dec);
        size = 0;
    }
    return size;
}

static inline uint64_t
vn_decode_array_size_unchecked(struct vn_cs_decoder *dec)
{
    uint64_t size;
    vn_decode_uint64_t(dec, &size);
    return size;
}

static inline uint64_t
vn_peek_array_size(struct vn_cs_decoder *dec)
{
    uint64_t size;
    vn_cs_decoder_peek(dec, sizeof(size), &size, sizeof(size));
    return size;
}

/* non-array pointer */

static inline size_t
vn_sizeof_simple_pointer(const void *val)
{
    return vn_sizeof_array_size(val ? 1 : 0);
}

static inline bool
vn_encode_simple_pointer(struct vn_cs_encoder *enc, const void *val)
{
    vn_encode_array_size(enc, val ? 1 : 0);
    return val;
}

static inline bool
vn_decode_simple_pointer(struct vn_cs_decoder *dec)
{
    return vn_decode_array_size_unchecked(dec);
}

/* uint32_t */

static inline size_t
vn_sizeof_uint32_t(const uint32_t *val)
{
    assert(sizeof(*val) == 4);
    return 4;
}

static inline void
vn_encode_uint32_t(struct vn_cs_encoder *enc, const uint32_t *val)
{
    vn_encode(enc, 4, val, sizeof(*val));
}

static inline void
vn_decode_uint32_t(struct vn_cs_decoder *dec, uint32_t *val)
{
    vn_decode(dec, 4, val, sizeof(*val));
}

static inline size_t
vn_sizeof_uint32_t_array(const uint32_t *val, uint32_t count)
{
    assert(sizeof(*val) == 4);
    const size_t size = sizeof(*val) * count;
    assert(size >= count);
    return size;
}

static inline void
vn_encode_uint32_t_array(struct vn_cs_encoder *enc, const uint32_t *val, uint32_t count)
{
    const size_t size = sizeof(*val) * count;
    assert(size >= count);
    vn_encode(enc, size, val, size);
}

static inline void
vn_decode_uint32_t_array(struct vn_cs_decoder *dec, uint32_t *val, uint32_t count)
{
    const size_t size = sizeof(*val) * count;
    assert(size >= count);
    vn_decode(dec, size, val, size);
}

/* float */

static inline size_t
vn_sizeof_float(const float *val)
{
    assert(sizeof(*val) == 4);
    return 4;
}

static inline void
vn_encode_float(struct vn_cs_encoder *enc, const float *val)
{
    vn_encode(enc, 4, val, sizeof(*val));
}

static inline void
vn_decode_float(struct vn_cs_decoder *dec, float *val)
{
    vn_decode(dec, 4, val, sizeof(*val));
}

static inline size_t
vn_sizeof_float_array(const float *val, uint32_t count)
{
    assert(sizeof(*val) == 4);
    const size_t size = sizeof(*val) * count;
    assert(size >= count);
    return size;
}

static inline void
vn_encode_float_array(struct vn_cs_encoder *enc, const float *val, uint32_t count)
{
    const size_t size = sizeof(*val) * count;
    assert(size >= count);
    vn_encode(enc, size, val, size);
}

static inline void
vn_decode_float_array(struct vn_cs_decoder *dec, float *val, uint32_t count)
{
    const size_t size = sizeof(*val) * count;
    assert(size >= count);
    vn_decode(dec, size, val, size);
}

/* uint8_t */

static inline size_t
vn_sizeof_uint8_t(const uint8_t *val)
{
    assert(sizeof(*val) == 1);
    return 4;
}

static inline void
vn_encode_uint8_t(struct vn_cs_encoder *enc, const uint8_t *val)
{
    vn_encode(enc, 4, val, sizeof(*val));
}

static inline void
vn_decode_uint8_t(struct vn_cs_decoder *dec, uint8_t *val)
{
    vn_decode(dec, 4, val, sizeof(*val));
}

static inline size_t
vn_sizeof_uint8_t_array(const uint8_t *val, uint32_t count)
{
    assert(sizeof(*val) == 1);
    const size_t size = sizeof(*val) * count;
    assert(size >= count);
    return (size + 3) & ~3;
}

static inline void
vn_encode_uint8_t_array(struct vn_cs_encoder *enc, const uint8_t *val, uint32_t count)
{
    const size_t size = sizeof(*val) * count;
    assert(size >= count);
    vn_encode(enc, (size + 3) & ~3, val, size);
}

static inline void
vn_decode_uint8_t_array(struct vn_cs_decoder *dec, uint8_t *val, uint32_t count)
{
    const size_t size = sizeof(*val) * count;
    assert(size >= count);
    vn_decode(dec, (size + 3) & ~3, val, size);
}

/* typedef uint32_t VkSampleMask */

static inline size_t
vn_sizeof_VkSampleMask(const VkSampleMask *val)
{
    return vn_sizeof_uint32_t(val);
}

static inline void
vn_encode_VkSampleMask(struct vn_cs_encoder *enc, const VkSampleMask *val)
{
    vn_encode_uint32_t(enc, val);
}

static inline void
vn_decode_VkSampleMask(struct vn_cs_decoder *dec, VkSampleMask *val)
{
    vn_decode_uint32_t(dec, val);
}

static inline size_t
vn_sizeof_VkSampleMask_array(const VkSampleMask *val, uint32_t count)
{
    return vn_sizeof_uint32_t_array(val, count);
}

static inline void
vn_encode_VkSampleMask_array(struct vn_cs_encoder *enc, const VkSampleMask *val, uint32_t count)
{
    vn_encode_uint32_t_array(enc, val, count);
}

static inline void
vn_decode_VkSampleMask_array(struct vn_cs_decoder *dec, VkSampleMask *val, uint32_t count)
{
    vn_decode_uint32_t_array(dec, val, count);
}

/* typedef uint32_t VkBool32 */

static inline size_t
vn_sizeof_VkBool32(const VkBool32 *val)
{
    return vn_sizeof_uint32_t(val);
}

static inline void
vn_encode_VkBool32(struct vn_cs_encoder *enc, const VkBool32 *val)
{
    vn_encode_uint32_t(enc, val);
}

static inline void
vn_decode_VkBool32(struct vn_cs_decoder *dec, VkBool32 *val)
{
    vn_decode_uint32_t(dec, val);
}

static inline size_t
vn_sizeof_VkBool32_array(const VkBool32 *val, uint32_t count)
{
    return vn_sizeof_uint32_t_array(val, count);
}

static inline void
vn_encode_VkBool32_array(struct vn_cs_encoder *enc, const VkBool32 *val, uint32_t count)
{
    vn_encode_uint32_t_array(enc, val, count);
}

static inline void
vn_decode_VkBool32_array(struct vn_cs_decoder *dec, VkBool32 *val, uint32_t count)
{
    vn_decode_uint32_t_array(dec, val, count);
}

/* typedef uint32_t VkFlags */

static inline size_t
vn_sizeof_VkFlags(const VkFlags *val)
{
    return vn_sizeof_uint32_t(val);
}

static inline void
vn_encode_VkFlags(struct vn_cs_encoder *enc, const VkFlags *val)
{
    vn_encode_uint32_t(enc, val);
}

static inline void
vn_decode_VkFlags(struct vn_cs_decoder *dec, VkFlags *val)
{
    vn_decode_uint32_t(dec, val);
}

static inline size_t
vn_sizeof_VkFlags_array(const VkFlags *val, uint32_t count)
{
    return vn_sizeof_uint32_t_array(val, count);
}

static inline void
vn_encode_VkFlags_array(struct vn_cs_encoder *enc, const VkFlags *val, uint32_t count)
{
    vn_encode_uint32_t_array(enc, val, count);
}

static inline void
vn_decode_VkFlags_array(struct vn_cs_decoder *dec, VkFlags *val, uint32_t count)
{
    vn_decode_uint32_t_array(dec, val, count);
}

/* typedef uint64_t VkDeviceSize */

static inline size_t
vn_sizeof_VkDeviceSize(const VkDeviceSize *val)
{
    return vn_sizeof_uint64_t(val);
}

static inline void
vn_encode_VkDeviceSize(struct vn_cs_encoder *enc, const VkDeviceSize *val)
{
    vn_encode_uint64_t(enc, val);
}

static inline void
vn_decode_VkDeviceSize(struct vn_cs_decoder *dec, VkDeviceSize *val)
{
    vn_decode_uint64_t(dec, val);
}

static inline size_t
vn_sizeof_VkDeviceSize_array(const VkDeviceSize *val, uint32_t count)
{
    return vn_sizeof_uint64_t_array(val, count);
}

static inline void
vn_encode_VkDeviceSize_array(struct vn_cs_encoder *enc, const VkDeviceSize *val, uint32_t count)
{
    vn_encode_uint64_t_array(enc, val, count);
}

static inline void
vn_decode_VkDeviceSize_array(struct vn_cs_decoder *dec, VkDeviceSize *val, uint32_t count)
{
    vn_decode_uint64_t_array(dec, val, count);
}

/* typedef uint64_t VkDeviceAddress */

static inline size_t
vn_sizeof_VkDeviceAddress(const VkDeviceAddress *val)
{
    return vn_sizeof_uint64_t(val);
}

static inline void
vn_encode_VkDeviceAddress(struct vn_cs_encoder *enc, const VkDeviceAddress *val)
{
    vn_encode_uint64_t(enc, val);
}

static inline void
vn_decode_VkDeviceAddress(struct vn_cs_decoder *dec, VkDeviceAddress *val)
{
    vn_decode_uint64_t(dec, val);
}

static inline size_t
vn_sizeof_VkDeviceAddress_array(const VkDeviceAddress *val, uint32_t count)
{
    return vn_sizeof_uint64_t_array(val, count);
}

static inline void
vn_encode_VkDeviceAddress_array(struct vn_cs_encoder *enc, const VkDeviceAddress *val, uint32_t count)
{
    vn_encode_uint64_t_array(enc, val, count);
}

static inline void
vn_decode_VkDeviceAddress_array(struct vn_cs_decoder *dec, VkDeviceAddress *val, uint32_t count)
{
    vn_decode_uint64_t_array(dec, val, count);
}

/* enum VkFramebufferCreateFlagBits */

static inline size_t
vn_sizeof_VkFramebufferCreateFlagBits(const VkFramebufferCreateFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkFramebufferCreateFlagBits(struct vn_cs_encoder *enc, const VkFramebufferCreateFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkFramebufferCreateFlagBits(struct vn_cs_decoder *dec, VkFramebufferCreateFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkRenderPassCreateFlagBits */

static inline size_t
vn_sizeof_VkRenderPassCreateFlagBits(const VkRenderPassCreateFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkRenderPassCreateFlagBits(struct vn_cs_encoder *enc, const VkRenderPassCreateFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkRenderPassCreateFlagBits(struct vn_cs_decoder *dec, VkRenderPassCreateFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSamplerCreateFlagBits */

static inline size_t
vn_sizeof_VkSamplerCreateFlagBits(const VkSamplerCreateFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSamplerCreateFlagBits(struct vn_cs_encoder *enc, const VkSamplerCreateFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSamplerCreateFlagBits(struct vn_cs_decoder *dec, VkSamplerCreateFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkPipelineCacheCreateFlagBits */

static inline size_t
vn_sizeof_VkPipelineCacheCreateFlagBits(const VkPipelineCacheCreateFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkPipelineCacheCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineCacheCreateFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkPipelineCacheCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineCacheCreateFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkPipelineShaderStageCreateFlagBits */

static inline size_t
vn_sizeof_VkPipelineShaderStageCreateFlagBits(const VkPipelineShaderStageCreateFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkPipelineShaderStageCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineShaderStageCreateFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkPipelineShaderStageCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineShaderStageCreateFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkDescriptorSetLayoutCreateFlagBits */

static inline size_t
vn_sizeof_VkDescriptorSetLayoutCreateFlagBits(const VkDescriptorSetLayoutCreateFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkDescriptorSetLayoutCreateFlagBits(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutCreateFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkDescriptorSetLayoutCreateFlagBits(struct vn_cs_decoder *dec, VkDescriptorSetLayoutCreateFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkDeviceQueueCreateFlagBits */

static inline size_t
vn_sizeof_VkDeviceQueueCreateFlagBits(const VkDeviceQueueCreateFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkDeviceQueueCreateFlagBits(struct vn_cs_encoder *enc, const VkDeviceQueueCreateFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkDeviceQueueCreateFlagBits(struct vn_cs_decoder *dec, VkDeviceQueueCreateFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkQueueFlagBits */

static inline size_t
vn_sizeof_VkQueueFlagBits(const VkQueueFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkQueueFlagBits(struct vn_cs_encoder *enc, const VkQueueFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkQueueFlagBits(struct vn_cs_decoder *dec, VkQueueFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkMemoryPropertyFlagBits */

static inline size_t
vn_sizeof_VkMemoryPropertyFlagBits(const VkMemoryPropertyFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkMemoryPropertyFlagBits(struct vn_cs_encoder *enc, const VkMemoryPropertyFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkMemoryPropertyFlagBits(struct vn_cs_decoder *dec, VkMemoryPropertyFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkMemoryHeapFlagBits */

static inline size_t
vn_sizeof_VkMemoryHeapFlagBits(const VkMemoryHeapFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkMemoryHeapFlagBits(struct vn_cs_encoder *enc, const VkMemoryHeapFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkMemoryHeapFlagBits(struct vn_cs_decoder *dec, VkMemoryHeapFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkAccessFlagBits */

static inline size_t
vn_sizeof_VkAccessFlagBits(const VkAccessFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkAccessFlagBits(struct vn_cs_encoder *enc, const VkAccessFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkAccessFlagBits(struct vn_cs_decoder *dec, VkAccessFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkBufferUsageFlagBits */

static inline size_t
vn_sizeof_VkBufferUsageFlagBits(const VkBufferUsageFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkBufferUsageFlagBits(struct vn_cs_encoder *enc, const VkBufferUsageFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkBufferUsageFlagBits(struct vn_cs_decoder *dec, VkBufferUsageFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkBufferCreateFlagBits */

static inline size_t
vn_sizeof_VkBufferCreateFlagBits(const VkBufferCreateFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkBufferCreateFlagBits(struct vn_cs_encoder *enc, const VkBufferCreateFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkBufferCreateFlagBits(struct vn_cs_decoder *dec, VkBufferCreateFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkShaderStageFlagBits */

static inline size_t
vn_sizeof_VkShaderStageFlagBits(const VkShaderStageFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkShaderStageFlagBits(struct vn_cs_encoder *enc, const VkShaderStageFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkShaderStageFlagBits(struct vn_cs_decoder *dec, VkShaderStageFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkImageUsageFlagBits */

static inline size_t
vn_sizeof_VkImageUsageFlagBits(const VkImageUsageFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkImageUsageFlagBits(struct vn_cs_encoder *enc, const VkImageUsageFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkImageUsageFlagBits(struct vn_cs_decoder *dec, VkImageUsageFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkImageCreateFlagBits */

static inline size_t
vn_sizeof_VkImageCreateFlagBits(const VkImageCreateFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkImageCreateFlagBits(struct vn_cs_encoder *enc, const VkImageCreateFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkImageCreateFlagBits(struct vn_cs_decoder *dec, VkImageCreateFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkImageViewCreateFlagBits */

static inline size_t
vn_sizeof_VkImageViewCreateFlagBits(const VkImageViewCreateFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkImageViewCreateFlagBits(struct vn_cs_encoder *enc, const VkImageViewCreateFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkImageViewCreateFlagBits(struct vn_cs_decoder *dec, VkImageViewCreateFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkPipelineCreateFlagBits */

static inline size_t
vn_sizeof_VkPipelineCreateFlagBits(const VkPipelineCreateFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkPipelineCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineCreateFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkPipelineCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineCreateFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkColorComponentFlagBits */

static inline size_t
vn_sizeof_VkColorComponentFlagBits(const VkColorComponentFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkColorComponentFlagBits(struct vn_cs_encoder *enc, const VkColorComponentFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkColorComponentFlagBits(struct vn_cs_decoder *dec, VkColorComponentFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkFenceCreateFlagBits */

static inline size_t
vn_sizeof_VkFenceCreateFlagBits(const VkFenceCreateFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkFenceCreateFlagBits(struct vn_cs_encoder *enc, const VkFenceCreateFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkFenceCreateFlagBits(struct vn_cs_decoder *dec, VkFenceCreateFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkFormatFeatureFlagBits */

static inline size_t
vn_sizeof_VkFormatFeatureFlagBits(const VkFormatFeatureFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkFormatFeatureFlagBits(struct vn_cs_encoder *enc, const VkFormatFeatureFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkFormatFeatureFlagBits(struct vn_cs_decoder *dec, VkFormatFeatureFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkQueryControlFlagBits */

static inline size_t
vn_sizeof_VkQueryControlFlagBits(const VkQueryControlFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkQueryControlFlagBits(struct vn_cs_encoder *enc, const VkQueryControlFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkQueryControlFlagBits(struct vn_cs_decoder *dec, VkQueryControlFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkQueryResultFlagBits */

static inline size_t
vn_sizeof_VkQueryResultFlagBits(const VkQueryResultFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkQueryResultFlagBits(struct vn_cs_encoder *enc, const VkQueryResultFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkQueryResultFlagBits(struct vn_cs_decoder *dec, VkQueryResultFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkEventCreateFlagBits */

static inline size_t
vn_sizeof_VkEventCreateFlagBits(const VkEventCreateFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkEventCreateFlagBits(struct vn_cs_encoder *enc, const VkEventCreateFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkEventCreateFlagBits(struct vn_cs_decoder *dec, VkEventCreateFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkCommandPoolCreateFlagBits */

static inline size_t
vn_sizeof_VkCommandPoolCreateFlagBits(const VkCommandPoolCreateFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkCommandPoolCreateFlagBits(struct vn_cs_encoder *enc, const VkCommandPoolCreateFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkCommandPoolCreateFlagBits(struct vn_cs_decoder *dec, VkCommandPoolCreateFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkCommandPoolResetFlagBits */

static inline size_t
vn_sizeof_VkCommandPoolResetFlagBits(const VkCommandPoolResetFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkCommandPoolResetFlagBits(struct vn_cs_encoder *enc, const VkCommandPoolResetFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkCommandPoolResetFlagBits(struct vn_cs_decoder *dec, VkCommandPoolResetFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkCommandBufferResetFlagBits */

static inline size_t
vn_sizeof_VkCommandBufferResetFlagBits(const VkCommandBufferResetFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkCommandBufferResetFlagBits(struct vn_cs_encoder *enc, const VkCommandBufferResetFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkCommandBufferResetFlagBits(struct vn_cs_decoder *dec, VkCommandBufferResetFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkCommandBufferUsageFlagBits */

static inline size_t
vn_sizeof_VkCommandBufferUsageFlagBits(const VkCommandBufferUsageFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkCommandBufferUsageFlagBits(struct vn_cs_encoder *enc, const VkCommandBufferUsageFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkCommandBufferUsageFlagBits(struct vn_cs_decoder *dec, VkCommandBufferUsageFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkQueryPipelineStatisticFlagBits */

static inline size_t
vn_sizeof_VkQueryPipelineStatisticFlagBits(const VkQueryPipelineStatisticFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkQueryPipelineStatisticFlagBits(struct vn_cs_encoder *enc, const VkQueryPipelineStatisticFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkQueryPipelineStatisticFlagBits(struct vn_cs_decoder *dec, VkQueryPipelineStatisticFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkImageAspectFlagBits */

static inline size_t
vn_sizeof_VkImageAspectFlagBits(const VkImageAspectFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkImageAspectFlagBits(struct vn_cs_encoder *enc, const VkImageAspectFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkImageAspectFlagBits(struct vn_cs_decoder *dec, VkImageAspectFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSparseMemoryBindFlagBits */

static inline size_t
vn_sizeof_VkSparseMemoryBindFlagBits(const VkSparseMemoryBindFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSparseMemoryBindFlagBits(struct vn_cs_encoder *enc, const VkSparseMemoryBindFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSparseMemoryBindFlagBits(struct vn_cs_decoder *dec, VkSparseMemoryBindFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSparseImageFormatFlagBits */

static inline size_t
vn_sizeof_VkSparseImageFormatFlagBits(const VkSparseImageFormatFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSparseImageFormatFlagBits(struct vn_cs_encoder *enc, const VkSparseImageFormatFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSparseImageFormatFlagBits(struct vn_cs_decoder *dec, VkSparseImageFormatFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSubpassDescriptionFlagBits */

static inline size_t
vn_sizeof_VkSubpassDescriptionFlagBits(const VkSubpassDescriptionFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSubpassDescriptionFlagBits(struct vn_cs_encoder *enc, const VkSubpassDescriptionFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSubpassDescriptionFlagBits(struct vn_cs_decoder *dec, VkSubpassDescriptionFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkPipelineStageFlagBits */

static inline size_t
vn_sizeof_VkPipelineStageFlagBits(const VkPipelineStageFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkPipelineStageFlagBits(struct vn_cs_encoder *enc, const VkPipelineStageFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkPipelineStageFlagBits(struct vn_cs_decoder *dec, VkPipelineStageFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSampleCountFlagBits */

static inline size_t
vn_sizeof_VkSampleCountFlagBits(const VkSampleCountFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSampleCountFlagBits(struct vn_cs_encoder *enc, const VkSampleCountFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSampleCountFlagBits(struct vn_cs_decoder *dec, VkSampleCountFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkAttachmentDescriptionFlagBits */

static inline size_t
vn_sizeof_VkAttachmentDescriptionFlagBits(const VkAttachmentDescriptionFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkAttachmentDescriptionFlagBits(struct vn_cs_encoder *enc, const VkAttachmentDescriptionFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkAttachmentDescriptionFlagBits(struct vn_cs_decoder *dec, VkAttachmentDescriptionFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkStencilFaceFlagBits */

static inline size_t
vn_sizeof_VkStencilFaceFlagBits(const VkStencilFaceFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkStencilFaceFlagBits(struct vn_cs_encoder *enc, const VkStencilFaceFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkStencilFaceFlagBits(struct vn_cs_decoder *dec, VkStencilFaceFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkCullModeFlagBits */

static inline size_t
vn_sizeof_VkCullModeFlagBits(const VkCullModeFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkCullModeFlagBits(struct vn_cs_encoder *enc, const VkCullModeFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkCullModeFlagBits(struct vn_cs_decoder *dec, VkCullModeFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkDescriptorPoolCreateFlagBits */

static inline size_t
vn_sizeof_VkDescriptorPoolCreateFlagBits(const VkDescriptorPoolCreateFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkDescriptorPoolCreateFlagBits(struct vn_cs_encoder *enc, const VkDescriptorPoolCreateFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkDescriptorPoolCreateFlagBits(struct vn_cs_decoder *dec, VkDescriptorPoolCreateFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkDependencyFlagBits */

static inline size_t
vn_sizeof_VkDependencyFlagBits(const VkDependencyFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkDependencyFlagBits(struct vn_cs_encoder *enc, const VkDependencyFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkDependencyFlagBits(struct vn_cs_decoder *dec, VkDependencyFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSubgroupFeatureFlagBits */

static inline size_t
vn_sizeof_VkSubgroupFeatureFlagBits(const VkSubgroupFeatureFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSubgroupFeatureFlagBits(struct vn_cs_encoder *enc, const VkSubgroupFeatureFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSubgroupFeatureFlagBits(struct vn_cs_decoder *dec, VkSubgroupFeatureFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSemaphoreWaitFlagBits */

static inline size_t
vn_sizeof_VkSemaphoreWaitFlagBits(const VkSemaphoreWaitFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSemaphoreWaitFlagBits(struct vn_cs_encoder *enc, const VkSemaphoreWaitFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSemaphoreWaitFlagBits(struct vn_cs_decoder *dec, VkSemaphoreWaitFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkPeerMemoryFeatureFlagBits */

static inline size_t
vn_sizeof_VkPeerMemoryFeatureFlagBits(const VkPeerMemoryFeatureFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkPeerMemoryFeatureFlagBits(struct vn_cs_encoder *enc, const VkPeerMemoryFeatureFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkPeerMemoryFeatureFlagBits(struct vn_cs_decoder *dec, VkPeerMemoryFeatureFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkMemoryAllocateFlagBits */

static inline size_t
vn_sizeof_VkMemoryAllocateFlagBits(const VkMemoryAllocateFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkMemoryAllocateFlagBits(struct vn_cs_encoder *enc, const VkMemoryAllocateFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkMemoryAllocateFlagBits(struct vn_cs_decoder *dec, VkMemoryAllocateFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkExternalMemoryHandleTypeFlagBits */

static inline size_t
vn_sizeof_VkExternalMemoryHandleTypeFlagBits(const VkExternalMemoryHandleTypeFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkExternalMemoryHandleTypeFlagBits(struct vn_cs_encoder *enc, const VkExternalMemoryHandleTypeFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkExternalMemoryHandleTypeFlagBits(struct vn_cs_decoder *dec, VkExternalMemoryHandleTypeFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkExternalMemoryFeatureFlagBits */

static inline size_t
vn_sizeof_VkExternalMemoryFeatureFlagBits(const VkExternalMemoryFeatureFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkExternalMemoryFeatureFlagBits(struct vn_cs_encoder *enc, const VkExternalMemoryFeatureFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkExternalMemoryFeatureFlagBits(struct vn_cs_decoder *dec, VkExternalMemoryFeatureFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkExternalSemaphoreHandleTypeFlagBits */

static inline size_t
vn_sizeof_VkExternalSemaphoreHandleTypeFlagBits(const VkExternalSemaphoreHandleTypeFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkExternalSemaphoreHandleTypeFlagBits(struct vn_cs_encoder *enc, const VkExternalSemaphoreHandleTypeFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkExternalSemaphoreHandleTypeFlagBits(struct vn_cs_decoder *dec, VkExternalSemaphoreHandleTypeFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkExternalSemaphoreFeatureFlagBits */

static inline size_t
vn_sizeof_VkExternalSemaphoreFeatureFlagBits(const VkExternalSemaphoreFeatureFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkExternalSemaphoreFeatureFlagBits(struct vn_cs_encoder *enc, const VkExternalSemaphoreFeatureFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkExternalSemaphoreFeatureFlagBits(struct vn_cs_decoder *dec, VkExternalSemaphoreFeatureFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSemaphoreImportFlagBits */

static inline size_t
vn_sizeof_VkSemaphoreImportFlagBits(const VkSemaphoreImportFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSemaphoreImportFlagBits(struct vn_cs_encoder *enc, const VkSemaphoreImportFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSemaphoreImportFlagBits(struct vn_cs_decoder *dec, VkSemaphoreImportFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkExternalFenceHandleTypeFlagBits */

static inline size_t
vn_sizeof_VkExternalFenceHandleTypeFlagBits(const VkExternalFenceHandleTypeFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkExternalFenceHandleTypeFlagBits(struct vn_cs_encoder *enc, const VkExternalFenceHandleTypeFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkExternalFenceHandleTypeFlagBits(struct vn_cs_decoder *dec, VkExternalFenceHandleTypeFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkExternalFenceFeatureFlagBits */

static inline size_t
vn_sizeof_VkExternalFenceFeatureFlagBits(const VkExternalFenceFeatureFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkExternalFenceFeatureFlagBits(struct vn_cs_encoder *enc, const VkExternalFenceFeatureFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkExternalFenceFeatureFlagBits(struct vn_cs_decoder *dec, VkExternalFenceFeatureFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkFenceImportFlagBits */

static inline size_t
vn_sizeof_VkFenceImportFlagBits(const VkFenceImportFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkFenceImportFlagBits(struct vn_cs_encoder *enc, const VkFenceImportFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkFenceImportFlagBits(struct vn_cs_decoder *dec, VkFenceImportFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkDescriptorBindingFlagBits */

static inline size_t
vn_sizeof_VkDescriptorBindingFlagBits(const VkDescriptorBindingFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkDescriptorBindingFlagBits(struct vn_cs_encoder *enc, const VkDescriptorBindingFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkDescriptorBindingFlagBits(struct vn_cs_decoder *dec, VkDescriptorBindingFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkResolveModeFlagBits */

static inline size_t
vn_sizeof_VkResolveModeFlagBits(const VkResolveModeFlagBits *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkResolveModeFlagBits(struct vn_cs_encoder *enc, const VkResolveModeFlagBits *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkResolveModeFlagBits(struct vn_cs_decoder *dec, VkResolveModeFlagBits *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkAttachmentLoadOp */

static inline size_t
vn_sizeof_VkAttachmentLoadOp(const VkAttachmentLoadOp *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkAttachmentLoadOp(struct vn_cs_encoder *enc, const VkAttachmentLoadOp *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkAttachmentLoadOp(struct vn_cs_decoder *dec, VkAttachmentLoadOp *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkAttachmentStoreOp */

static inline size_t
vn_sizeof_VkAttachmentStoreOp(const VkAttachmentStoreOp *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkAttachmentStoreOp(struct vn_cs_encoder *enc, const VkAttachmentStoreOp *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkAttachmentStoreOp(struct vn_cs_decoder *dec, VkAttachmentStoreOp *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkBlendFactor */

static inline size_t
vn_sizeof_VkBlendFactor(const VkBlendFactor *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkBlendFactor(struct vn_cs_encoder *enc, const VkBlendFactor *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkBlendFactor(struct vn_cs_decoder *dec, VkBlendFactor *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkBlendOp */

static inline size_t
vn_sizeof_VkBlendOp(const VkBlendOp *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkBlendOp(struct vn_cs_encoder *enc, const VkBlendOp *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkBlendOp(struct vn_cs_decoder *dec, VkBlendOp *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkBorderColor */

static inline size_t
vn_sizeof_VkBorderColor(const VkBorderColor *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkBorderColor(struct vn_cs_encoder *enc, const VkBorderColor *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkBorderColor(struct vn_cs_decoder *dec, VkBorderColor *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkPipelineCacheHeaderVersion */

static inline size_t
vn_sizeof_VkPipelineCacheHeaderVersion(const VkPipelineCacheHeaderVersion *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkPipelineCacheHeaderVersion(struct vn_cs_encoder *enc, const VkPipelineCacheHeaderVersion *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkPipelineCacheHeaderVersion(struct vn_cs_decoder *dec, VkPipelineCacheHeaderVersion *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkComponentSwizzle */

static inline size_t
vn_sizeof_VkComponentSwizzle(const VkComponentSwizzle *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkComponentSwizzle(struct vn_cs_encoder *enc, const VkComponentSwizzle *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkComponentSwizzle(struct vn_cs_decoder *dec, VkComponentSwizzle *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkCommandBufferLevel */

static inline size_t
vn_sizeof_VkCommandBufferLevel(const VkCommandBufferLevel *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkCommandBufferLevel(struct vn_cs_encoder *enc, const VkCommandBufferLevel *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkCommandBufferLevel(struct vn_cs_decoder *dec, VkCommandBufferLevel *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkCompareOp */

static inline size_t
vn_sizeof_VkCompareOp(const VkCompareOp *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkCompareOp(struct vn_cs_encoder *enc, const VkCompareOp *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkCompareOp(struct vn_cs_decoder *dec, VkCompareOp *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkDescriptorType */

static inline size_t
vn_sizeof_VkDescriptorType(const VkDescriptorType *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkDescriptorType(struct vn_cs_encoder *enc, const VkDescriptorType *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkDescriptorType(struct vn_cs_decoder *dec, VkDescriptorType *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

static inline size_t
vn_sizeof_VkDescriptorType_array(const VkDescriptorType *val, uint32_t count)
{
    return vn_sizeof_int32_t_array((const int32_t *)val, count);
}

static inline void
vn_encode_VkDescriptorType_array(struct vn_cs_encoder *enc, const VkDescriptorType *val, uint32_t count)
{
    vn_encode_int32_t_array(enc, (const int32_t *)val, count);
}

static inline void
vn_decode_VkDescriptorType_array(struct vn_cs_decoder *dec, VkDescriptorType *val, uint32_t count)
{
    vn_decode_int32_t_array(dec, (int32_t *)val, count);
}

/* enum VkDynamicState */

static inline size_t
vn_sizeof_VkDynamicState(const VkDynamicState *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkDynamicState(struct vn_cs_encoder *enc, const VkDynamicState *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkDynamicState(struct vn_cs_decoder *dec, VkDynamicState *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

static inline size_t
vn_sizeof_VkDynamicState_array(const VkDynamicState *val, uint32_t count)
{
    return vn_sizeof_int32_t_array((const int32_t *)val, count);
}

static inline void
vn_encode_VkDynamicState_array(struct vn_cs_encoder *enc, const VkDynamicState *val, uint32_t count)
{
    vn_encode_int32_t_array(enc, (const int32_t *)val, count);
}

static inline void
vn_decode_VkDynamicState_array(struct vn_cs_decoder *dec, VkDynamicState *val, uint32_t count)
{
    vn_decode_int32_t_array(dec, (int32_t *)val, count);
}

/* enum VkPolygonMode */

static inline size_t
vn_sizeof_VkPolygonMode(const VkPolygonMode *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkPolygonMode(struct vn_cs_encoder *enc, const VkPolygonMode *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkPolygonMode(struct vn_cs_decoder *dec, VkPolygonMode *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkFormat */

static inline size_t
vn_sizeof_VkFormat(const VkFormat *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkFormat(struct vn_cs_encoder *enc, const VkFormat *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkFormat(struct vn_cs_decoder *dec, VkFormat *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

static inline size_t
vn_sizeof_VkFormat_array(const VkFormat *val, uint32_t count)
{
    return vn_sizeof_int32_t_array((const int32_t *)val, count);
}

static inline void
vn_encode_VkFormat_array(struct vn_cs_encoder *enc, const VkFormat *val, uint32_t count)
{
    vn_encode_int32_t_array(enc, (const int32_t *)val, count);
}

static inline void
vn_decode_VkFormat_array(struct vn_cs_decoder *dec, VkFormat *val, uint32_t count)
{
    vn_decode_int32_t_array(dec, (int32_t *)val, count);
}

/* enum VkFrontFace */

static inline size_t
vn_sizeof_VkFrontFace(const VkFrontFace *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkFrontFace(struct vn_cs_encoder *enc, const VkFrontFace *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkFrontFace(struct vn_cs_decoder *dec, VkFrontFace *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkImageLayout */

static inline size_t
vn_sizeof_VkImageLayout(const VkImageLayout *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkImageLayout(struct vn_cs_encoder *enc, const VkImageLayout *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkImageLayout(struct vn_cs_decoder *dec, VkImageLayout *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkImageTiling */

static inline size_t
vn_sizeof_VkImageTiling(const VkImageTiling *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkImageTiling(struct vn_cs_encoder *enc, const VkImageTiling *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkImageTiling(struct vn_cs_decoder *dec, VkImageTiling *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkImageType */

static inline size_t
vn_sizeof_VkImageType(const VkImageType *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkImageType(struct vn_cs_encoder *enc, const VkImageType *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkImageType(struct vn_cs_decoder *dec, VkImageType *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkImageViewType */

static inline size_t
vn_sizeof_VkImageViewType(const VkImageViewType *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkImageViewType(struct vn_cs_encoder *enc, const VkImageViewType *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkImageViewType(struct vn_cs_decoder *dec, VkImageViewType *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSharingMode */

static inline size_t
vn_sizeof_VkSharingMode(const VkSharingMode *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSharingMode(struct vn_cs_encoder *enc, const VkSharingMode *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSharingMode(struct vn_cs_decoder *dec, VkSharingMode *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkIndexType */

static inline size_t
vn_sizeof_VkIndexType(const VkIndexType *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkIndexType(struct vn_cs_encoder *enc, const VkIndexType *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkIndexType(struct vn_cs_decoder *dec, VkIndexType *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

static inline size_t
vn_sizeof_VkIndexType_array(const VkIndexType *val, uint32_t count)
{
    return vn_sizeof_int32_t_array((const int32_t *)val, count);
}

static inline void
vn_encode_VkIndexType_array(struct vn_cs_encoder *enc, const VkIndexType *val, uint32_t count)
{
    vn_encode_int32_t_array(enc, (const int32_t *)val, count);
}

static inline void
vn_decode_VkIndexType_array(struct vn_cs_decoder *dec, VkIndexType *val, uint32_t count)
{
    vn_decode_int32_t_array(dec, (int32_t *)val, count);
}

/* enum VkLogicOp */

static inline size_t
vn_sizeof_VkLogicOp(const VkLogicOp *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkLogicOp(struct vn_cs_encoder *enc, const VkLogicOp *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkLogicOp(struct vn_cs_decoder *dec, VkLogicOp *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkPhysicalDeviceType */

static inline size_t
vn_sizeof_VkPhysicalDeviceType(const VkPhysicalDeviceType *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkPhysicalDeviceType(struct vn_cs_encoder *enc, const VkPhysicalDeviceType *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkPhysicalDeviceType(struct vn_cs_decoder *dec, VkPhysicalDeviceType *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkPipelineBindPoint */

static inline size_t
vn_sizeof_VkPipelineBindPoint(const VkPipelineBindPoint *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkPipelineBindPoint(struct vn_cs_encoder *enc, const VkPipelineBindPoint *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkPipelineBindPoint(struct vn_cs_decoder *dec, VkPipelineBindPoint *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkPrimitiveTopology */

static inline size_t
vn_sizeof_VkPrimitiveTopology(const VkPrimitiveTopology *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkPrimitiveTopology(struct vn_cs_encoder *enc, const VkPrimitiveTopology *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkPrimitiveTopology(struct vn_cs_decoder *dec, VkPrimitiveTopology *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkQueryType */

static inline size_t
vn_sizeof_VkQueryType(const VkQueryType *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkQueryType(struct vn_cs_encoder *enc, const VkQueryType *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkQueryType(struct vn_cs_decoder *dec, VkQueryType *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSubpassContents */

static inline size_t
vn_sizeof_VkSubpassContents(const VkSubpassContents *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSubpassContents(struct vn_cs_encoder *enc, const VkSubpassContents *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSubpassContents(struct vn_cs_decoder *dec, VkSubpassContents *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkResult */

static inline size_t
vn_sizeof_VkResult(const VkResult *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkResult(struct vn_cs_encoder *enc, const VkResult *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkResult(struct vn_cs_decoder *dec, VkResult *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

static inline size_t
vn_sizeof_VkResult_array(const VkResult *val, uint32_t count)
{
    return vn_sizeof_int32_t_array((const int32_t *)val, count);
}

static inline void
vn_encode_VkResult_array(struct vn_cs_encoder *enc, const VkResult *val, uint32_t count)
{
    vn_encode_int32_t_array(enc, (const int32_t *)val, count);
}

static inline void
vn_decode_VkResult_array(struct vn_cs_decoder *dec, VkResult *val, uint32_t count)
{
    vn_decode_int32_t_array(dec, (int32_t *)val, count);
}

/* enum VkStencilOp */

static inline size_t
vn_sizeof_VkStencilOp(const VkStencilOp *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkStencilOp(struct vn_cs_encoder *enc, const VkStencilOp *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkStencilOp(struct vn_cs_decoder *dec, VkStencilOp *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSystemAllocationScope */

static inline size_t
vn_sizeof_VkSystemAllocationScope(const VkSystemAllocationScope *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSystemAllocationScope(struct vn_cs_encoder *enc, const VkSystemAllocationScope *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSystemAllocationScope(struct vn_cs_decoder *dec, VkSystemAllocationScope *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkInternalAllocationType */

static inline size_t
vn_sizeof_VkInternalAllocationType(const VkInternalAllocationType *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkInternalAllocationType(struct vn_cs_encoder *enc, const VkInternalAllocationType *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkInternalAllocationType(struct vn_cs_decoder *dec, VkInternalAllocationType *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSamplerAddressMode */

static inline size_t
vn_sizeof_VkSamplerAddressMode(const VkSamplerAddressMode *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSamplerAddressMode(struct vn_cs_encoder *enc, const VkSamplerAddressMode *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSamplerAddressMode(struct vn_cs_decoder *dec, VkSamplerAddressMode *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkFilter */

static inline size_t
vn_sizeof_VkFilter(const VkFilter *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkFilter(struct vn_cs_encoder *enc, const VkFilter *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkFilter(struct vn_cs_decoder *dec, VkFilter *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSamplerMipmapMode */

static inline size_t
vn_sizeof_VkSamplerMipmapMode(const VkSamplerMipmapMode *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSamplerMipmapMode(struct vn_cs_encoder *enc, const VkSamplerMipmapMode *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSamplerMipmapMode(struct vn_cs_decoder *dec, VkSamplerMipmapMode *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkVertexInputRate */

static inline size_t
vn_sizeof_VkVertexInputRate(const VkVertexInputRate *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkVertexInputRate(struct vn_cs_encoder *enc, const VkVertexInputRate *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkVertexInputRate(struct vn_cs_decoder *dec, VkVertexInputRate *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkObjectType */

static inline size_t
vn_sizeof_VkObjectType(const VkObjectType *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkObjectType(struct vn_cs_encoder *enc, const VkObjectType *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkObjectType(struct vn_cs_decoder *dec, VkObjectType *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkDescriptorUpdateTemplateType */

static inline size_t
vn_sizeof_VkDescriptorUpdateTemplateType(const VkDescriptorUpdateTemplateType *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkDescriptorUpdateTemplateType(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplateType *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkDescriptorUpdateTemplateType(struct vn_cs_decoder *dec, VkDescriptorUpdateTemplateType *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkPointClippingBehavior */

static inline size_t
vn_sizeof_VkPointClippingBehavior(const VkPointClippingBehavior *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkPointClippingBehavior(struct vn_cs_encoder *enc, const VkPointClippingBehavior *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkPointClippingBehavior(struct vn_cs_decoder *dec, VkPointClippingBehavior *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSemaphoreType */

static inline size_t
vn_sizeof_VkSemaphoreType(const VkSemaphoreType *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSemaphoreType(struct vn_cs_encoder *enc, const VkSemaphoreType *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSemaphoreType(struct vn_cs_decoder *dec, VkSemaphoreType *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkTessellationDomainOrigin */

static inline size_t
vn_sizeof_VkTessellationDomainOrigin(const VkTessellationDomainOrigin *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkTessellationDomainOrigin(struct vn_cs_encoder *enc, const VkTessellationDomainOrigin *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkTessellationDomainOrigin(struct vn_cs_decoder *dec, VkTessellationDomainOrigin *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSamplerYcbcrModelConversion */

static inline size_t
vn_sizeof_VkSamplerYcbcrModelConversion(const VkSamplerYcbcrModelConversion *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSamplerYcbcrModelConversion(struct vn_cs_encoder *enc, const VkSamplerYcbcrModelConversion *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSamplerYcbcrModelConversion(struct vn_cs_decoder *dec, VkSamplerYcbcrModelConversion *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSamplerYcbcrRange */

static inline size_t
vn_sizeof_VkSamplerYcbcrRange(const VkSamplerYcbcrRange *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSamplerYcbcrRange(struct vn_cs_encoder *enc, const VkSamplerYcbcrRange *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSamplerYcbcrRange(struct vn_cs_decoder *dec, VkSamplerYcbcrRange *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkChromaLocation */

static inline size_t
vn_sizeof_VkChromaLocation(const VkChromaLocation *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkChromaLocation(struct vn_cs_encoder *enc, const VkChromaLocation *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkChromaLocation(struct vn_cs_decoder *dec, VkChromaLocation *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkSamplerReductionMode */

static inline size_t
vn_sizeof_VkSamplerReductionMode(const VkSamplerReductionMode *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkSamplerReductionMode(struct vn_cs_encoder *enc, const VkSamplerReductionMode *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkSamplerReductionMode(struct vn_cs_decoder *dec, VkSamplerReductionMode *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkShaderFloatControlsIndependence */

static inline size_t
vn_sizeof_VkShaderFloatControlsIndependence(const VkShaderFloatControlsIndependence *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkShaderFloatControlsIndependence(struct vn_cs_encoder *enc, const VkShaderFloatControlsIndependence *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkShaderFloatControlsIndependence(struct vn_cs_decoder *dec, VkShaderFloatControlsIndependence *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkVendorId */

static inline size_t
vn_sizeof_VkVendorId(const VkVendorId *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkVendorId(struct vn_cs_encoder *enc, const VkVendorId *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkVendorId(struct vn_cs_decoder *dec, VkVendorId *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkDriverId */

static inline size_t
vn_sizeof_VkDriverId(const VkDriverId *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkDriverId(struct vn_cs_encoder *enc, const VkDriverId *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkDriverId(struct vn_cs_decoder *dec, VkDriverId *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkCommandFlagBitsEXT */

static inline size_t
vn_sizeof_VkCommandFlagBitsEXT(const VkCommandFlagBitsEXT *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkCommandFlagBitsEXT(struct vn_cs_encoder *enc, const VkCommandFlagBitsEXT *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkCommandFlagBitsEXT(struct vn_cs_decoder *dec, VkCommandFlagBitsEXT *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

/* enum VkCommandTypeEXT */

static inline size_t
vn_sizeof_VkCommandTypeEXT(const VkCommandTypeEXT *val)
{
    assert(sizeof(*val) == sizeof(int32_t));
    return vn_sizeof_int32_t((const int32_t *)val);
}

static inline void
vn_encode_VkCommandTypeEXT(struct vn_cs_encoder *enc, const VkCommandTypeEXT *val)
{
    vn_encode_int32_t(enc, (const int32_t *)val);
}

static inline void
vn_decode_VkCommandTypeEXT(struct vn_cs_decoder *dec, VkCommandTypeEXT *val)
{
    vn_decode_int32_t(dec, (int32_t *)val);
}

#endif /* VN_PROTOCOL_DRIVER_TYPES_H */