////////////////////////////////////////////////////////////////////////////////
// Do not modify!
// Generated by codergen
////////////////////////////////////////////////////////////////////////////////


#ifndef GAPIC_CODER_VULKAN_H
#define GAPIC_CODER_VULKAN_H

#include <gapic/schema.h>
#include <gapic/coder/memory.h>
#include <gapic/coder/vulkan.h>
#include <gapic/vector.h>

#include <gapic/static_array.h>
namespace gapic {

class Encodable;
class Encoder;

namespace coder {
namespace vulkan {
    class ANativeWindow__S: public Encodable {
    public:
        ANativeWindow__S() = default;
        ANativeWindow__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class ANativeWindow__P: public Encodable {
    public:
        ANativeWindow__P() = default;
        ANativeWindow__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Char__256__A: public Encodable {
    public:
        Char__256__A() = default;
        Char__256__A(const gapic::StaticArray<char, 256>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 256; i++) {
                e->Uint8(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<char, 256> mElements;
    };

    class Char__S: public Encodable {
    public:
        Char__S() = default;
        Char__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Char__P: public Encodable {
    public:
        Char__P() = default;
        Char__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Char__CP: public Encodable {
    public:
        Char__CP() = default;
        Char__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Char__CP__S: public Encodable {
    public:
        Char__CP__S() = default;
        Char__CP__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Char__CP__P: public Encodable {
    public:
        Char__CP__P() = default;
        Char__CP__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Char__CP__CP: public Encodable {
    public:
        Char__CP__CP() = default;
        Char__CP__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkImageSubresourceLayers: public Encodable {
    public:
        VkImageSubresourceLayers() = default;
        VkImageSubresourceLayers(uint32_t AspectMask, uint32_t MipLevel, uint32_t BaseArrayLayer, uint32_t LayerCount)
                : mAspectMask(AspectMask)
                , mMipLevel(MipLevel)
                , mBaseArrayLayer(BaseArrayLayer)
                , mLayerCount(LayerCount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mAspectMask;
        uint32_t mMipLevel;
        uint32_t mBaseArrayLayer;
        uint32_t mLayerCount;
    };

    class VkOffset3D: public Encodable {
    public:
        VkOffset3D() = default;
        VkOffset3D(int32_t X, int32_t Y, int32_t Z)
                : mX(X)
                , mY(Y)
                , mZ(Z) {}
        virtual void Encode(Encoder* e) const{
            e->Int32(this->mX);
            e->Int32(this->mY);
            e->Int32(this->mZ);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        int32_t mX;
        int32_t mY;
        int32_t mZ;
    };

    class VkExtent3D: public Encodable {
    public:
        VkExtent3D() = default;
        VkExtent3D(uint32_t Width, uint32_t Height, uint32_t Depth)
                : mWidth(Width)
                , mHeight(Height)
                , mDepth(Depth) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mWidth);
            e->Uint32(this->mHeight);
            e->Uint32(this->mDepth);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mWidth;
        uint32_t mHeight;
        uint32_t mDepth;
    };

    class VkBufferImageCopy: public Encodable {
    public:
        VkBufferImageCopy() = default;
        VkBufferImageCopy(uint64_t BufferOffset, uint32_t BufferRowLength, uint32_t BufferImageHeight, VkImageSubresourceLayers ImageSubresource, VkOffset3D ImageOffset, VkExtent3D ImageExtent)
                : mBufferOffset(BufferOffset)
                , mBufferRowLength(BufferRowLength)
                , mBufferImageHeight(BufferImageHeight)
                , mImageSubresource(ImageSubresource)
                , mImageOffset(ImageOffset)
                , mImageExtent(ImageExtent) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mBufferOffset;
        uint32_t mBufferRowLength;
        uint32_t mBufferImageHeight;
        VkImageSubresourceLayers mImageSubresource;
        VkOffset3D mImageOffset;
        VkExtent3D mImageExtent;
    };

    class Void__CP: public Encodable {
    public:
        Void__CP() = default;
        Void__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkImageSubresourceRange: public Encodable {
    public:
        VkImageSubresourceRange() = default;
        VkImageSubresourceRange(uint32_t AspectMask, uint32_t BaseMipLevel, uint32_t LevelCount, uint32_t BaseArrayLayer, uint32_t LayerCount)
                : mAspectMask(AspectMask)
                , mBaseMipLevel(BaseMipLevel)
                , mLevelCount(LevelCount)
                , mBaseArrayLayer(BaseArrayLayer)
                , mLayerCount(LayerCount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mAspectMask;
        uint32_t mBaseMipLevel;
        uint32_t mLevelCount;
        uint32_t mBaseArrayLayer;
        uint32_t mLayerCount;
    };

    class VkImageMemoryBarrier: public Encodable {
    public:
        VkImageMemoryBarrier() = default;
        VkImageMemoryBarrier(uint32_t SType, Void__CP PNext, uint32_t SrcAccessMask, uint32_t DstAccessMask, uint32_t OldLayout, uint32_t NewLayout, uint32_t SrcQueueFamilyIndex, uint32_t DstQueueFamilyIndex, uint64_t Image, VkImageSubresourceRange SubresourceRange)
                : mSType(SType)
                , mPNext(PNext)
                , mSrcAccessMask(SrcAccessMask)
                , mDstAccessMask(DstAccessMask)
                , mOldLayout(OldLayout)
                , mNewLayout(NewLayout)
                , mSrcQueueFamilyIndex(SrcQueueFamilyIndex)
                , mDstQueueFamilyIndex(DstQueueFamilyIndex)
                , mImage(Image)
                , mSubresourceRange(SubresourceRange) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mSrcAccessMask;
        uint32_t mDstAccessMask;
        uint32_t mOldLayout;
        uint32_t mNewLayout;
        uint32_t mSrcQueueFamilyIndex;
        uint32_t mDstQueueFamilyIndex;
        uint64_t mImage;
        VkImageSubresourceRange mSubresourceRange;
    };

    class VkDescriptorBufferInfo: public Encodable {
    public:
        VkDescriptorBufferInfo() = default;
        VkDescriptorBufferInfo(uint64_t Buffer, uint64_t Offset, uint64_t Range)
                : mBuffer(Buffer)
                , mOffset(Offset)
                , mRange(Range) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mBuffer);
            e->Uint64(this->mOffset);
            e->Uint64(this->mRange);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mBuffer;
        uint64_t mOffset;
        uint64_t mRange;
    };

    class Void__P: public Encodable {
    public:
        Void__P() = default;
        Void__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class U8__S: public Encodable {
    public:
        U8__S() = default;
        U8__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPhysicalDeviceFeatures: public Encodable {
    public:
        VkPhysicalDeviceFeatures() = default;
        VkPhysicalDeviceFeatures(uint32_t RobustBufferAccess, uint32_t FullDrawIndexUint32, uint32_t ImageCubeArray, uint32_t IndependentBlend, uint32_t GeometryShader, uint32_t TessellationShader, uint32_t SampleRateShading, uint32_t DualSrcBlend, uint32_t LogicOp, uint32_t MultiDrawIndirect, uint32_t DrawIndirectFirstInstance, uint32_t DepthClamp, uint32_t DepthBiasClamp, uint32_t FillModeNonSolid, uint32_t DepthBounds, uint32_t WideLines, uint32_t LargePoints, uint32_t AlphaToOne, uint32_t MultiViewport, uint32_t SamplerAnisotropy, uint32_t TextureCompressionETC2, uint32_t TextureCompressionASTC_LDR, uint32_t TextureCompressionBC, uint32_t OcclusionQueryPrecise, uint32_t PipelineStatisticsQuery, uint32_t VertexPipelineStoresAndAtomics, uint32_t FragmentStoresAndAtomics, uint32_t ShaderTessellationAndGeometryPointSize, uint32_t ShaderImageGatherExtended, uint32_t ShaderStorageImageExtendedFormats, uint32_t ShaderStorageImageMultisample, uint32_t ShaderStorageImageReadWithoutFormat, uint32_t ShaderStorageImageWriteWithoutFormat, uint32_t ShaderUniformBufferArrayDynamicIndexing, uint32_t ShaderSampledImageArrayDynamicIndexing, uint32_t ShaderStorageBufferArrayDynamicIndexing, uint32_t ShaderStorageImageArrayDynamicIndexing, uint32_t ShaderClipDistance, uint32_t ShaderCullDistance, uint32_t ShaderFloat64, uint32_t ShaderInt64, uint32_t ShaderInt16, uint32_t ShaderResourceResidency, uint32_t ShaderResourceMinLod, uint32_t SparseBinding, uint32_t SparseResidencyBuffer, uint32_t SparseResidencyImage2D, uint32_t SparseResidencyImage3D, uint32_t SparseResidency2Samples, uint32_t SparseResidency4Samples, uint32_t SparseResidency8Samples, uint32_t SparseResidency16Samples, uint32_t SparseResidencyAliased, uint32_t VariableMultisampleRate, uint32_t InheritedQueries)
                : mRobustBufferAccess(RobustBufferAccess)
                , mFullDrawIndexUint32(FullDrawIndexUint32)
                , mImageCubeArray(ImageCubeArray)
                , mIndependentBlend(IndependentBlend)
                , mGeometryShader(GeometryShader)
                , mTessellationShader(TessellationShader)
                , mSampleRateShading(SampleRateShading)
                , mDualSrcBlend(DualSrcBlend)
                , mLogicOp(LogicOp)
                , mMultiDrawIndirect(MultiDrawIndirect)
                , mDrawIndirectFirstInstance(DrawIndirectFirstInstance)
                , mDepthClamp(DepthClamp)
                , mDepthBiasClamp(DepthBiasClamp)
                , mFillModeNonSolid(FillModeNonSolid)
                , mDepthBounds(DepthBounds)
                , mWideLines(WideLines)
                , mLargePoints(LargePoints)
                , mAlphaToOne(AlphaToOne)
                , mMultiViewport(MultiViewport)
                , mSamplerAnisotropy(SamplerAnisotropy)
                , mTextureCompressionETC2(TextureCompressionETC2)
                , mTextureCompressionASTC_LDR(TextureCompressionASTC_LDR)
                , mTextureCompressionBC(TextureCompressionBC)
                , mOcclusionQueryPrecise(OcclusionQueryPrecise)
                , mPipelineStatisticsQuery(PipelineStatisticsQuery)
                , mVertexPipelineStoresAndAtomics(VertexPipelineStoresAndAtomics)
                , mFragmentStoresAndAtomics(FragmentStoresAndAtomics)
                , mShaderTessellationAndGeometryPointSize(ShaderTessellationAndGeometryPointSize)
                , mShaderImageGatherExtended(ShaderImageGatherExtended)
                , mShaderStorageImageExtendedFormats(ShaderStorageImageExtendedFormats)
                , mShaderStorageImageMultisample(ShaderStorageImageMultisample)
                , mShaderStorageImageReadWithoutFormat(ShaderStorageImageReadWithoutFormat)
                , mShaderStorageImageWriteWithoutFormat(ShaderStorageImageWriteWithoutFormat)
                , mShaderUniformBufferArrayDynamicIndexing(ShaderUniformBufferArrayDynamicIndexing)
                , mShaderSampledImageArrayDynamicIndexing(ShaderSampledImageArrayDynamicIndexing)
                , mShaderStorageBufferArrayDynamicIndexing(ShaderStorageBufferArrayDynamicIndexing)
                , mShaderStorageImageArrayDynamicIndexing(ShaderStorageImageArrayDynamicIndexing)
                , mShaderClipDistance(ShaderClipDistance)
                , mShaderCullDistance(ShaderCullDistance)
                , mShaderFloat64(ShaderFloat64)
                , mShaderInt64(ShaderInt64)
                , mShaderInt16(ShaderInt16)
                , mShaderResourceResidency(ShaderResourceResidency)
                , mShaderResourceMinLod(ShaderResourceMinLod)
                , mSparseBinding(SparseBinding)
                , mSparseResidencyBuffer(SparseResidencyBuffer)
                , mSparseResidencyImage2D(SparseResidencyImage2D)
                , mSparseResidencyImage3D(SparseResidencyImage3D)
                , mSparseResidency2Samples(SparseResidency2Samples)
                , mSparseResidency4Samples(SparseResidency4Samples)
                , mSparseResidency8Samples(SparseResidency8Samples)
                , mSparseResidency16Samples(SparseResidency16Samples)
                , mSparseResidencyAliased(SparseResidencyAliased)
                , mVariableMultisampleRate(VariableMultisampleRate)
                , mInheritedQueries(InheritedQueries) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mRobustBufferAccess;
        uint32_t mFullDrawIndexUint32;
        uint32_t mImageCubeArray;
        uint32_t mIndependentBlend;
        uint32_t mGeometryShader;
        uint32_t mTessellationShader;
        uint32_t mSampleRateShading;
        uint32_t mDualSrcBlend;
        uint32_t mLogicOp;
        uint32_t mMultiDrawIndirect;
        uint32_t mDrawIndirectFirstInstance;
        uint32_t mDepthClamp;
        uint32_t mDepthBiasClamp;
        uint32_t mFillModeNonSolid;
        uint32_t mDepthBounds;
        uint32_t mWideLines;
        uint32_t mLargePoints;
        uint32_t mAlphaToOne;
        uint32_t mMultiViewport;
        uint32_t mSamplerAnisotropy;
        uint32_t mTextureCompressionETC2;
        uint32_t mTextureCompressionASTC_LDR;
        uint32_t mTextureCompressionBC;
        uint32_t mOcclusionQueryPrecise;
        uint32_t mPipelineStatisticsQuery;
        uint32_t mVertexPipelineStoresAndAtomics;
        uint32_t mFragmentStoresAndAtomics;
        uint32_t mShaderTessellationAndGeometryPointSize;
        uint32_t mShaderImageGatherExtended;
        uint32_t mShaderStorageImageExtendedFormats;
        uint32_t mShaderStorageImageMultisample;
        uint32_t mShaderStorageImageReadWithoutFormat;
        uint32_t mShaderStorageImageWriteWithoutFormat;
        uint32_t mShaderUniformBufferArrayDynamicIndexing;
        uint32_t mShaderSampledImageArrayDynamicIndexing;
        uint32_t mShaderStorageBufferArrayDynamicIndexing;
        uint32_t mShaderStorageImageArrayDynamicIndexing;
        uint32_t mShaderClipDistance;
        uint32_t mShaderCullDistance;
        uint32_t mShaderFloat64;
        uint32_t mShaderInt64;
        uint32_t mShaderInt16;
        uint32_t mShaderResourceResidency;
        uint32_t mShaderResourceMinLod;
        uint32_t mSparseBinding;
        uint32_t mSparseResidencyBuffer;
        uint32_t mSparseResidencyImage2D;
        uint32_t mSparseResidencyImage3D;
        uint32_t mSparseResidency2Samples;
        uint32_t mSparseResidency4Samples;
        uint32_t mSparseResidency8Samples;
        uint32_t mSparseResidency16Samples;
        uint32_t mSparseResidencyAliased;
        uint32_t mVariableMultisampleRate;
        uint32_t mInheritedQueries;
    };

    class Display__S: public Encodable {
    public:
        Display__S() = default;
        Display__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Display__P: public Encodable {
    public:
        Display__P() = default;
        Display__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class F32__2__A: public Encodable {
    public:
        F32__2__A() = default;
        F32__2__A(const gapic::StaticArray<float, 2>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 2; i++) {
                e->Float32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<float, 2> mElements;
    };

    class F32__4__A: public Encodable {
    public:
        F32__4__A() = default;
        F32__4__A(const gapic::StaticArray<float, 4>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 4; i++) {
                e->Float32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<float, 4> mElements;
    };

    class F32__S: public Encodable {
    public:
        F32__S() = default;
        F32__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class F32__P: public Encodable {
    public:
        F32__P() = default;
        F32__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class F32__CP: public Encodable {
    public:
        F32__CP() = default;
        F32__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Int__S: public Encodable {
    public:
        Int__S() = default;
        Int__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Int__P: public Encodable {
    public:
        Int__P() = default;
        Int__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class MirConnection__S: public Encodable {
    public:
        MirConnection__S() = default;
        MirConnection__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class MirConnection__P: public Encodable {
    public:
        MirConnection__P() = default;
        MirConnection__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class MirSurface__S: public Encodable {
    public:
        MirSurface__S() = default;
        MirSurface__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class MirSurface__P: public Encodable {
    public:
        MirSurface__P() = default;
        MirSurface__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class PFN_vkAllocationFunction: public Encodable {
    public:
        PFN_vkAllocationFunction() = default;
        PFN_vkAllocationFunction(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class PFN_vkDebugReportCallbackEXT: public Encodable {
    public:
        PFN_vkDebugReportCallbackEXT() = default;
        PFN_vkDebugReportCallbackEXT(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class PFN_vkFreeFunction: public Encodable {
    public:
        PFN_vkFreeFunction() = default;
        PFN_vkFreeFunction(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class PFN_vkInternalAllocationNotification: public Encodable {
    public:
        PFN_vkInternalAllocationNotification() = default;
        PFN_vkInternalAllocationNotification(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class PFN_vkInternalFreeNotification: public Encodable {
    public:
        PFN_vkInternalFreeNotification() = default;
        PFN_vkInternalFreeNotification(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class PFN_vkReallocationFunction: public Encodable {
    public:
        PFN_vkReallocationFunction() = default;
        PFN_vkReallocationFunction(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class PFN_vkVoidFunction: public Encodable {
    public:
        PFN_vkVoidFunction() = default;
        PFN_vkVoidFunction(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkMemoryType: public Encodable {
    public:
        VkMemoryType() = default;
        VkMemoryType(uint32_t PropertyFlags, uint32_t HeapIndex)
                : mPropertyFlags(PropertyFlags)
                , mHeapIndex(HeapIndex) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mPropertyFlags);
            e->Uint32(this->mHeapIndex);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mPropertyFlags;
        uint32_t mHeapIndex;
    };

    class VkMemoryType__32__A: public Encodable {
    public:
        VkMemoryType__32__A() = default;
        VkMemoryType__32__A(const gapic::StaticArray<VkMemoryType, 32>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 32; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<VkMemoryType, 32> mElements;
    };

    class VkMemoryHeap: public Encodable {
    public:
        VkMemoryHeap() = default;
        VkMemoryHeap(uint64_t Size, uint32_t Flags)
                : mSize(Size)
                , mFlags(Flags) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mSize);
            e->Uint32(this->mFlags);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mSize;
        uint32_t mFlags;
    };

    class VkMemoryHeap__16__A: public Encodable {
    public:
        VkMemoryHeap__16__A() = default;
        VkMemoryHeap__16__A(const gapic::StaticArray<VkMemoryHeap, 16>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 16; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<VkMemoryHeap, 16> mElements;
    };

    class VkPhysicalDeviceMemoryProperties: public Encodable {
    public:
        VkPhysicalDeviceMemoryProperties() = default;
        VkPhysicalDeviceMemoryProperties(uint32_t MemoryTypeCount, VkMemoryType__32__A MemoryTypes, uint32_t MemoryHeapCount, VkMemoryHeap__16__A MemoryHeaps)
                : mMemoryTypeCount(MemoryTypeCount)
                , mMemoryTypes(MemoryTypes)
                , mMemoryHeapCount(MemoryHeapCount)
                , mMemoryHeaps(MemoryHeaps) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mMemoryTypeCount;
        VkMemoryType__32__A mMemoryTypes;
        uint32_t mMemoryHeapCount;
        VkMemoryHeap__16__A mMemoryHeaps;
    };

    class VkDeviceCreateInfo__CP: public Encodable {
    public:
        VkDeviceCreateInfo__CP() = default;
        VkDeviceCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkAllocationCallbacks__CP: public Encodable {
    public:
        VkAllocationCallbacks__CP() = default;
        VkAllocationCallbacks__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDevice__P: public Encodable {
    public:
        VkDevice__P() = default;
        VkDevice__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class ReplayCreateVkDevice: public Encodable {
    public:
        ReplayCreateVkDevice() = default;
        ReplayCreateVkDevice(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, VkDeviceCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkDevice__P PDevice, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPDevice(PDevice)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        VkDeviceCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkDevice__P mPDevice;
        uint32_t mResult;
    };

    class VkInstanceCreateInfo__CP: public Encodable {
    public:
        VkInstanceCreateInfo__CP() = default;
        VkInstanceCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkInstance__P: public Encodable {
    public:
        VkInstance__P() = default;
        VkInstance__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class ReplayCreateVkInstance: public Encodable {
    public:
        ReplayCreateVkInstance() = default;
        ReplayCreateVkInstance(const gapic::Vector<gapic::Encodable*>& extras, VkInstanceCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkInstance__P PInstance, uint32_t Result)
                : mextras(extras)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPInstance(PInstance)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        VkInstanceCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkInstance__P mPInstance;
        uint32_t mResult;
    };

    class VkCommandBuffer__P: public Encodable {
    public:
        VkCommandBuffer__P() = default;
        VkCommandBuffer__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class ReplayRegisterVkCommandBuffers: public Encodable {
    public:
        ReplayRegisterVkCommandBuffers() = default;
        ReplayRegisterVkCommandBuffers(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t Count, VkCommandBuffer__P CommandBuffers)
                : mextras(extras)
                , mDevice(Device)
                , mCount(Count)
                , mCommandBuffers(CommandBuffers) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint32_t mCount;
        VkCommandBuffer__P mCommandBuffers;
    };

    class VkDeviceCreateInfo__P: public Encodable {
    public:
        VkDeviceCreateInfo__P() = default;
        VkDeviceCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class ReplayRegisterVkDevice: public Encodable {
    public:
        ReplayRegisterVkDevice() = default;
        ReplayRegisterVkDevice(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint64_t Device, VkDeviceCreateInfo__P CreateInfo)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mDevice(Device)
                , mCreateInfo(CreateInfo) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        uint64_t mDevice;
        VkDeviceCreateInfo__P mCreateInfo;
    };

    class ReplayRegisterVkInstance: public Encodable {
    public:
        ReplayRegisterVkInstance() = default;
        ReplayRegisterVkInstance(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance)
                : mextras(extras)
                , mInstance(Instance) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mInstance);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mInstance;
    };

    class ReplayUnregisterVkCommandBuffers: public Encodable {
    public:
        ReplayUnregisterVkCommandBuffers() = default;
        ReplayUnregisterVkCommandBuffers(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Count, VkCommandBuffer__P CommandBuffers)
                : mextras(extras)
                , mCount(Count)
                , mCommandBuffers(CommandBuffers) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mCount);
            e->Struct(this->mCommandBuffers);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCount;
        VkCommandBuffer__P mCommandBuffers;
    };

    class ReplayUnregisterVkDevice: public Encodable {
    public:
        ReplayUnregisterVkDevice() = default;
        ReplayUnregisterVkDevice(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device)
                : mextras(extras)
                , mDevice(Device) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mDevice);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
    };

    class ReplayUnregisterVkInstance: public Encodable {
    public:
        ReplayUnregisterVkInstance() = default;
        ReplayUnregisterVkInstance(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance)
                : mextras(extras)
                , mInstance(Instance) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mInstance);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mInstance;
    };

    class U32__S: public Encodable {
    public:
        U32__S() = default;
        U32__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Size__S: public Encodable {
    public:
        Size__S() = default;
        Size__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Size__P: public Encodable {
    public:
        Size__P() = default;
        Size__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSwapchainKHR__P: public Encodable {
    public:
        VkSwapchainKHR__P() = default;
        VkSwapchainKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class ToggleVirtualSwapchainReturnAcquiredImage: public Encodable {
    public:
        ToggleVirtualSwapchainReturnAcquiredImage() = default;
        ToggleVirtualSwapchainReturnAcquiredImage(const gapic::Vector<gapic::Encodable*>& extras, VkSwapchainKHR__P PSwapchain)
                : mextras(extras)
                , mPSwapchain(PSwapchain) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mPSwapchain);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        VkSwapchainKHR__P mPSwapchain;
    };

    class U32__2__A: public Encodable {
    public:
        U32__2__A() = default;
        U32__2__A(const gapic::StaticArray<uint32_t, 2>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 2; i++) {
                e->Uint32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<uint32_t, 2> mElements;
    };

    class U32__3__A: public Encodable {
    public:
        U32__3__A() = default;
        U32__3__A(const gapic::StaticArray<uint32_t, 3>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 3; i++) {
                e->Uint32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<uint32_t, 3> mElements;
    };

    class U32__4__A: public Encodable {
    public:
        U32__4__A() = default;
        U32__4__A(const gapic::StaticArray<uint32_t, 4>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 4; i++) {
                e->Uint32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<uint32_t, 4> mElements;
    };

    class U32__P: public Encodable {
    public:
        U32__P() = default;
        U32__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class U32__CP: public Encodable {
    public:
        U32__CP() = default;
        U32__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class U8__16__A: public Encodable {
    public:
        U8__16__A() = default;
        U8__16__A(const gapic::StaticArray<uint8_t, 16>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            e->Data(this->mElements, 16);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<uint8_t, 16> mElements;
    };

    class U8__P: public Encodable {
    public:
        U8__P() = default;
        U8__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkAcquireImageANDROID: public Encodable {
    public:
        VkAcquireImageANDROID() = default;
        VkAcquireImageANDROID(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Image, int64_t NativeFenceFd, uint64_t Semaphore, uint64_t Fence, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mImage(Image)
                , mNativeFenceFd(NativeFenceFd)
                , mSemaphore(Semaphore)
                , mFence(Fence)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mImage;
        int64_t mNativeFenceFd;
        uint64_t mSemaphore;
        uint64_t mFence;
        uint32_t mResult;
    };

    class VkAcquireNextImageKHR: public Encodable {
    public:
        VkAcquireNextImageKHR() = default;
        VkAcquireNextImageKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Swapchain, uint64_t Timeout, uint64_t Semaphore, uint64_t Fence, U32__P PImageIndex, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mSwapchain(Swapchain)
                , mTimeout(Timeout)
                , mSemaphore(Semaphore)
                , mFence(Fence)
                , mPImageIndex(PImageIndex)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mSwapchain;
        uint64_t mTimeout;
        uint64_t mSemaphore;
        uint64_t mFence;
        U32__P mPImageIndex;
        uint32_t mResult;
    };

    class VkCommandBufferAllocateInfo__CP: public Encodable {
    public:
        VkCommandBufferAllocateInfo__CP() = default;
        VkCommandBufferAllocateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkAllocateCommandBuffers: public Encodable {
    public:
        VkAllocateCommandBuffers() = default;
        VkAllocateCommandBuffers(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkCommandBufferAllocateInfo__CP PAllocateInfo, VkCommandBuffer__P PCommandBuffers, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPAllocateInfo(PAllocateInfo)
                , mPCommandBuffers(PCommandBuffers)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkCommandBufferAllocateInfo__CP mPAllocateInfo;
        VkCommandBuffer__P mPCommandBuffers;
        uint32_t mResult;
    };

    class VkDescriptorSetAllocateInfo__CP: public Encodable {
    public:
        VkDescriptorSetAllocateInfo__CP() = default;
        VkDescriptorSetAllocateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDescriptorSet__P: public Encodable {
    public:
        VkDescriptorSet__P() = default;
        VkDescriptorSet__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkAllocateDescriptorSets: public Encodable {
    public:
        VkAllocateDescriptorSets() = default;
        VkAllocateDescriptorSets(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkDescriptorSetAllocateInfo__CP PAllocateInfo, VkDescriptorSet__P PDescriptorSets, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPAllocateInfo(PAllocateInfo)
                , mPDescriptorSets(PDescriptorSets)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkDescriptorSetAllocateInfo__CP mPAllocateInfo;
        VkDescriptorSet__P mPDescriptorSets;
        uint32_t mResult;
    };

    class VkMemoryAllocateInfo__CP: public Encodable {
    public:
        VkMemoryAllocateInfo__CP() = default;
        VkMemoryAllocateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDeviceMemory__P: public Encodable {
    public:
        VkDeviceMemory__P() = default;
        VkDeviceMemory__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkAllocateMemory: public Encodable {
    public:
        VkAllocateMemory() = default;
        VkAllocateMemory(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkMemoryAllocateInfo__CP PAllocateInfo, VkAllocationCallbacks__CP PAllocator, VkDeviceMemory__P PMemory, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPAllocateInfo(PAllocateInfo)
                , mPAllocator(PAllocator)
                , mPMemory(PMemory)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkMemoryAllocateInfo__CP mPAllocateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkDeviceMemory__P mPMemory;
        uint32_t mResult;
    };

    class VkAllocationCallbacks: public Encodable {
    public:
        VkAllocationCallbacks() = default;
        VkAllocationCallbacks(Void__P PUserData, PFN_vkAllocationFunction PfnAllocation, PFN_vkReallocationFunction PfnReallocation, PFN_vkFreeFunction PfnFree, PFN_vkInternalAllocationNotification PfnInternalAllocation, PFN_vkInternalFreeNotification PfnInternalFree)
                : mPUserData(PUserData)
                , mPfnAllocation(PfnAllocation)
                , mPfnReallocation(PfnReallocation)
                , mPfnFree(PfnFree)
                , mPfnInternalAllocation(PfnInternalAllocation)
                , mPfnInternalFree(PfnInternalFree) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        Void__P mPUserData;
        PFN_vkAllocationFunction mPfnAllocation;
        PFN_vkReallocationFunction mPfnReallocation;
        PFN_vkFreeFunction mPfnFree;
        PFN_vkInternalAllocationNotification mPfnInternalAllocation;
        PFN_vkInternalFreeNotification mPfnInternalFree;
    };

    class VkAllocationCallbacks__S: public Encodable {
    public:
        VkAllocationCallbacks__S() = default;
        VkAllocationCallbacks__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkAllocationCallbacks__P: public Encodable {
    public:
        VkAllocationCallbacks__P() = default;
        VkAllocationCallbacks__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkAndroidSurfaceCreateInfoKHR__S: public Encodable {
    public:
        VkAndroidSurfaceCreateInfoKHR__S() = default;
        VkAndroidSurfaceCreateInfoKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkAndroidSurfaceCreateInfoKHR__P: public Encodable {
    public:
        VkAndroidSurfaceCreateInfoKHR__P() = default;
        VkAndroidSurfaceCreateInfoKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkAndroidSurfaceCreateInfoKHR__CP: public Encodable {
    public:
        VkAndroidSurfaceCreateInfoKHR__CP() = default;
        VkAndroidSurfaceCreateInfoKHR__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkApplicationInfo: public Encodable {
    public:
        VkApplicationInfo() = default;
        VkApplicationInfo(uint32_t SType, Void__CP PNext, Char__CP PApplicationName, uint32_t ApplicationVersion, Char__CP PEngineName, uint32_t EngineVersion, uint32_t ApiVersion)
                : mSType(SType)
                , mPNext(PNext)
                , mPApplicationName(PApplicationName)
                , mApplicationVersion(ApplicationVersion)
                , mPEngineName(PEngineName)
                , mEngineVersion(EngineVersion)
                , mApiVersion(ApiVersion) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        Char__CP mPApplicationName;
        uint32_t mApplicationVersion;
        Char__CP mPEngineName;
        uint32_t mEngineVersion;
        uint32_t mApiVersion;
    };

    class VkApplicationInfo__S: public Encodable {
    public:
        VkApplicationInfo__S() = default;
        VkApplicationInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkApplicationInfo__P: public Encodable {
    public:
        VkApplicationInfo__P() = default;
        VkApplicationInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkApplicationInfo__CP: public Encodable {
    public:
        VkApplicationInfo__CP() = default;
        VkApplicationInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkAttachmentDescription: public Encodable {
    public:
        VkAttachmentDescription() = default;
        VkAttachmentDescription(uint32_t Flags, uint32_t Format, uint32_t Samples, uint32_t LoadOp, uint32_t StoreOp, uint32_t StencilLoadOp, uint32_t StencilStoreOp, uint32_t InitialLayout, uint32_t FinalLayout)
                : mFlags(Flags)
                , mFormat(Format)
                , mSamples(Samples)
                , mLoadOp(LoadOp)
                , mStoreOp(StoreOp)
                , mStencilLoadOp(StencilLoadOp)
                , mStencilStoreOp(StencilStoreOp)
                , mInitialLayout(InitialLayout)
                , mFinalLayout(FinalLayout) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mFlags;
        uint32_t mFormat;
        uint32_t mSamples;
        uint32_t mLoadOp;
        uint32_t mStoreOp;
        uint32_t mStencilLoadOp;
        uint32_t mStencilStoreOp;
        uint32_t mInitialLayout;
        uint32_t mFinalLayout;
    };

    class VkAttachmentDescription__S: public Encodable {
    public:
        VkAttachmentDescription__S() = default;
        VkAttachmentDescription__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkAttachmentDescription__P: public Encodable {
    public:
        VkAttachmentDescription__P() = default;
        VkAttachmentDescription__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkAttachmentDescription__CP: public Encodable {
    public:
        VkAttachmentDescription__CP() = default;
        VkAttachmentDescription__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkAttachmentReference: public Encodable {
    public:
        VkAttachmentReference() = default;
        VkAttachmentReference(uint32_t Attachment, uint32_t Layout)
                : mAttachment(Attachment)
                , mLayout(Layout) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mAttachment);
            e->Uint32(this->mLayout);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mAttachment;
        uint32_t mLayout;
    };

    class VkAttachmentReference__S: public Encodable {
    public:
        VkAttachmentReference__S() = default;
        VkAttachmentReference__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkAttachmentReference__P: public Encodable {
    public:
        VkAttachmentReference__P() = default;
        VkAttachmentReference__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkAttachmentReference__CP: public Encodable {
    public:
        VkAttachmentReference__CP() = default;
        VkAttachmentReference__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCommandBufferBeginInfo__CP: public Encodable {
    public:
        VkCommandBufferBeginInfo__CP() = default;
        VkCommandBufferBeginInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBeginCommandBuffer: public Encodable {
    public:
        VkBeginCommandBuffer() = default;
        VkBeginCommandBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, VkCommandBufferBeginInfo__CP PBeginInfo, uint32_t Result)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mPBeginInfo(PBeginInfo)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        VkCommandBufferBeginInfo__CP mPBeginInfo;
        uint32_t mResult;
    };

    class VkBindBufferMemory: public Encodable {
    public:
        VkBindBufferMemory() = default;
        VkBindBufferMemory(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Buffer, uint64_t Memory, uint64_t MemoryOffset, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mBuffer(Buffer)
                , mMemory(Memory)
                , mMemoryOffset(MemoryOffset)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mBuffer;
        uint64_t mMemory;
        uint64_t mMemoryOffset;
        uint32_t mResult;
    };

    class VkBindImageMemory: public Encodable {
    public:
        VkBindImageMemory() = default;
        VkBindImageMemory(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Image, uint64_t Memory, uint64_t MemoryOffset, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mImage(Image)
                , mMemory(Memory)
                , mMemoryOffset(MemoryOffset)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mImage;
        uint64_t mMemory;
        uint64_t mMemoryOffset;
        uint32_t mResult;
    };

    class VkSemaphore__CP: public Encodable {
    public:
        VkSemaphore__CP() = default;
        VkSemaphore__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSparseBufferMemoryBindInfo__CP: public Encodable {
    public:
        VkSparseBufferMemoryBindInfo__CP() = default;
        VkSparseBufferMemoryBindInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSparseImageOpaqueMemoryBindInfo__CP: public Encodable {
    public:
        VkSparseImageOpaqueMemoryBindInfo__CP() = default;
        VkSparseImageOpaqueMemoryBindInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSparseImageMemoryBindInfo__CP: public Encodable {
    public:
        VkSparseImageMemoryBindInfo__CP() = default;
        VkSparseImageMemoryBindInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBindSparseInfo: public Encodable {
    public:
        VkBindSparseInfo() = default;
        VkBindSparseInfo(uint32_t SType, Void__CP PNext, uint32_t WaitSemaphoreCount, VkSemaphore__CP PWaitSemaphores, uint32_t NumBufferBinds, VkSparseBufferMemoryBindInfo__CP PBufferBinds, uint32_t NumImageOpaqueBinds, VkSparseImageOpaqueMemoryBindInfo__CP PImageOpaqueBinds, uint32_t NumImageBinds, VkSparseImageMemoryBindInfo__CP PImageBinds, uint32_t SignalSemaphoreCount, VkSemaphore__CP PSignalSemaphores)
                : mSType(SType)
                , mPNext(PNext)
                , mWaitSemaphoreCount(WaitSemaphoreCount)
                , mPWaitSemaphores(PWaitSemaphores)
                , mNumBufferBinds(NumBufferBinds)
                , mPBufferBinds(PBufferBinds)
                , mNumImageOpaqueBinds(NumImageOpaqueBinds)
                , mPImageOpaqueBinds(PImageOpaqueBinds)
                , mNumImageBinds(NumImageBinds)
                , mPImageBinds(PImageBinds)
                , mSignalSemaphoreCount(SignalSemaphoreCount)
                , mPSignalSemaphores(PSignalSemaphores) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mWaitSemaphoreCount;
        VkSemaphore__CP mPWaitSemaphores;
        uint32_t mNumBufferBinds;
        VkSparseBufferMemoryBindInfo__CP mPBufferBinds;
        uint32_t mNumImageOpaqueBinds;
        VkSparseImageOpaqueMemoryBindInfo__CP mPImageOpaqueBinds;
        uint32_t mNumImageBinds;
        VkSparseImageMemoryBindInfo__CP mPImageBinds;
        uint32_t mSignalSemaphoreCount;
        VkSemaphore__CP mPSignalSemaphores;
    };

    class VkBindSparseInfo__S: public Encodable {
    public:
        VkBindSparseInfo__S() = default;
        VkBindSparseInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkBindSparseInfo__P: public Encodable {
    public:
        VkBindSparseInfo__P() = default;
        VkBindSparseInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBindSparseInfo__CP: public Encodable {
    public:
        VkBindSparseInfo__CP() = default;
        VkBindSparseInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBool32__S: public Encodable {
    public:
        VkBool32__S() = default;
        VkBool32__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkBool32__P: public Encodable {
    public:
        VkBool32__P() = default;
        VkBool32__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBufferCopy: public Encodable {
    public:
        VkBufferCopy() = default;
        VkBufferCopy(uint64_t SrcOffset, uint64_t DstOffset, uint64_t Size)
                : mSrcOffset(SrcOffset)
                , mDstOffset(DstOffset)
                , mSize(Size) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mSrcOffset);
            e->Uint64(this->mDstOffset);
            e->Uint64(this->mSize);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mSrcOffset;
        uint64_t mDstOffset;
        uint64_t mSize;
    };

    class VkBufferCopy__S: public Encodable {
    public:
        VkBufferCopy__S() = default;
        VkBufferCopy__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkBufferCopy__P: public Encodable {
    public:
        VkBufferCopy__P() = default;
        VkBufferCopy__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBufferCopy__CP: public Encodable {
    public:
        VkBufferCopy__CP() = default;
        VkBufferCopy__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBufferCreateInfo: public Encodable {
    public:
        VkBufferCreateInfo() = default;
        VkBufferCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint64_t Size, uint32_t Usage, uint32_t SharingMode, uint32_t QueueFamilyIndexCount, U32__CP PQueueFamilyIndices)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mSize(Size)
                , mUsage(Usage)
                , mSharingMode(SharingMode)
                , mQueueFamilyIndexCount(QueueFamilyIndexCount)
                , mPQueueFamilyIndices(PQueueFamilyIndices) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint64_t mSize;
        uint32_t mUsage;
        uint32_t mSharingMode;
        uint32_t mQueueFamilyIndexCount;
        U32__CP mPQueueFamilyIndices;
    };

    class VkBufferCreateInfo__S: public Encodable {
    public:
        VkBufferCreateInfo__S() = default;
        VkBufferCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkBufferCreateInfo__P: public Encodable {
    public:
        VkBufferCreateInfo__P() = default;
        VkBufferCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBufferCreateInfo__CP: public Encodable {
    public:
        VkBufferCreateInfo__CP() = default;
        VkBufferCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBufferImageCopy__S: public Encodable {
    public:
        VkBufferImageCopy__S() = default;
        VkBufferImageCopy__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkBufferImageCopy__P: public Encodable {
    public:
        VkBufferImageCopy__P() = default;
        VkBufferImageCopy__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBufferImageCopy__CP: public Encodable {
    public:
        VkBufferImageCopy__CP() = default;
        VkBufferImageCopy__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBufferMemoryBarrier: public Encodable {
    public:
        VkBufferMemoryBarrier() = default;
        VkBufferMemoryBarrier(uint32_t SType, Void__CP PNext, uint32_t SrcAccessMask, uint32_t DstAccessMask, uint32_t SrcQueueFamilyIndex, uint32_t DstQueueFamilyIndex, uint64_t Buffer, uint64_t Offset, uint64_t Size)
                : mSType(SType)
                , mPNext(PNext)
                , mSrcAccessMask(SrcAccessMask)
                , mDstAccessMask(DstAccessMask)
                , mSrcQueueFamilyIndex(SrcQueueFamilyIndex)
                , mDstQueueFamilyIndex(DstQueueFamilyIndex)
                , mBuffer(Buffer)
                , mOffset(Offset)
                , mSize(Size) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mSrcAccessMask;
        uint32_t mDstAccessMask;
        uint32_t mSrcQueueFamilyIndex;
        uint32_t mDstQueueFamilyIndex;
        uint64_t mBuffer;
        uint64_t mOffset;
        uint64_t mSize;
    };

    class VkBufferMemoryBarrier__S: public Encodable {
    public:
        VkBufferMemoryBarrier__S() = default;
        VkBufferMemoryBarrier__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkBufferMemoryBarrier__P: public Encodable {
    public:
        VkBufferMemoryBarrier__P() = default;
        VkBufferMemoryBarrier__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBufferMemoryBarrier__CP: public Encodable {
    public:
        VkBufferMemoryBarrier__CP() = default;
        VkBufferMemoryBarrier__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBufferViewCreateInfo: public Encodable {
    public:
        VkBufferViewCreateInfo() = default;
        VkBufferViewCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint64_t Buffer, uint32_t Format, uint64_t Offset, uint64_t Range)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mBuffer(Buffer)
                , mFormat(Format)
                , mOffset(Offset)
                , mRange(Range) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint64_t mBuffer;
        uint32_t mFormat;
        uint64_t mOffset;
        uint64_t mRange;
    };

    class VkBufferViewCreateInfo__S: public Encodable {
    public:
        VkBufferViewCreateInfo__S() = default;
        VkBufferViewCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkBufferViewCreateInfo__P: public Encodable {
    public:
        VkBufferViewCreateInfo__P() = default;
        VkBufferViewCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBufferViewCreateInfo__CP: public Encodable {
    public:
        VkBufferViewCreateInfo__CP() = default;
        VkBufferViewCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBufferView__S: public Encodable {
    public:
        VkBufferView__S() = default;
        VkBufferView__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkBufferView__P: public Encodable {
    public:
        VkBufferView__P() = default;
        VkBufferView__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBufferView__CP: public Encodable {
    public:
        VkBufferView__CP() = default;
        VkBufferView__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBuffer__S: public Encodable {
    public:
        VkBuffer__S() = default;
        VkBuffer__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkBuffer__P: public Encodable {
    public:
        VkBuffer__P() = default;
        VkBuffer__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkBuffer__CP: public Encodable {
    public:
        VkBuffer__CP() = default;
        VkBuffer__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkClearColorValue: public Encodable {
    public:
        VkClearColorValue() = default;
        VkClearColorValue(U32__4__A Uint32)
                : mUint32(Uint32) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mUint32);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        U32__4__A mUint32;
    };

    class VkClearValue: public Encodable {
    public:
        VkClearValue() = default;
        VkClearValue(VkClearColorValue Color)
                : mColor(Color) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mColor);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        VkClearColorValue mColor;
    };

    class VkClearAttachment: public Encodable {
    public:
        VkClearAttachment() = default;
        VkClearAttachment(uint32_t AspectMask, uint32_t ColorAttachment, VkClearValue ClearValue)
                : mAspectMask(AspectMask)
                , mColorAttachment(ColorAttachment)
                , mClearValue(ClearValue) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mAspectMask);
            e->Uint32(this->mColorAttachment);
            e->Struct(this->mClearValue);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mAspectMask;
        uint32_t mColorAttachment;
        VkClearValue mClearValue;
    };

    class VkClearAttachment__S: public Encodable {
    public:
        VkClearAttachment__S() = default;
        VkClearAttachment__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkClearAttachment__P: public Encodable {
    public:
        VkClearAttachment__P() = default;
        VkClearAttachment__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkClearAttachment__CP: public Encodable {
    public:
        VkClearAttachment__CP() = default;
        VkClearAttachment__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkClearColorValue__S: public Encodable {
    public:
        VkClearColorValue__S() = default;
        VkClearColorValue__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkClearColorValue__P: public Encodable {
    public:
        VkClearColorValue__P() = default;
        VkClearColorValue__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkClearColorValue__CP: public Encodable {
    public:
        VkClearColorValue__CP() = default;
        VkClearColorValue__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkClearDepthStencilValue: public Encodable {
    public:
        VkClearDepthStencilValue() = default;
        VkClearDepthStencilValue(float Depth, uint32_t Stencil)
                : mDepth(Depth)
                , mStencil(Stencil) {}
        virtual void Encode(Encoder* e) const{
            e->Float32(this->mDepth);
            e->Uint32(this->mStencil);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        float mDepth;
        uint32_t mStencil;
    };

    class VkClearDepthStencilValue__S: public Encodable {
    public:
        VkClearDepthStencilValue__S() = default;
        VkClearDepthStencilValue__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkClearDepthStencilValue__P: public Encodable {
    public:
        VkClearDepthStencilValue__P() = default;
        VkClearDepthStencilValue__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkClearDepthStencilValue__CP: public Encodable {
    public:
        VkClearDepthStencilValue__CP() = default;
        VkClearDepthStencilValue__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkOffset2D: public Encodable {
    public:
        VkOffset2D() = default;
        VkOffset2D(int32_t X, int32_t Y)
                : mX(X)
                , mY(Y) {}
        virtual void Encode(Encoder* e) const{
            e->Int32(this->mX);
            e->Int32(this->mY);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        int32_t mX;
        int32_t mY;
    };

    class VkExtent2D: public Encodable {
    public:
        VkExtent2D() = default;
        VkExtent2D(uint32_t Width, uint32_t Height)
                : mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mWidth);
            e->Uint32(this->mHeight);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mWidth;
        uint32_t mHeight;
    };

    class VkRect2D: public Encodable {
    public:
        VkRect2D() = default;
        VkRect2D(VkOffset2D Offset, VkExtent2D Extent)
                : mOffset(Offset)
                , mExtent(Extent) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mOffset);
            e->Struct(this->mExtent);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        VkOffset2D mOffset;
        VkExtent2D mExtent;
    };

    class VkClearRect: public Encodable {
    public:
        VkClearRect() = default;
        VkClearRect(VkRect2D Rect, uint32_t BaseArrayLayer, uint32_t LayerCount)
                : mRect(Rect)
                , mBaseArrayLayer(BaseArrayLayer)
                , mLayerCount(LayerCount) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mRect);
            e->Uint32(this->mBaseArrayLayer);
            e->Uint32(this->mLayerCount);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        VkRect2D mRect;
        uint32_t mBaseArrayLayer;
        uint32_t mLayerCount;
    };

    class VkClearRect__S: public Encodable {
    public:
        VkClearRect__S() = default;
        VkClearRect__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkClearRect__P: public Encodable {
    public:
        VkClearRect__P() = default;
        VkClearRect__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkClearRect__CP: public Encodable {
    public:
        VkClearRect__CP() = default;
        VkClearRect__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkClearValue__S: public Encodable {
    public:
        VkClearValue__S() = default;
        VkClearValue__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkClearValue__P: public Encodable {
    public:
        VkClearValue__P() = default;
        VkClearValue__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkClearValue__CP: public Encodable {
    public:
        VkClearValue__CP() = default;
        VkClearValue__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCmdBeginQuery: public Encodable {
    public:
        VkCmdBeginQuery() = default;
        VkCmdBeginQuery(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t QueryPool, uint32_t Query, uint32_t Flags)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mQueryPool(QueryPool)
                , mQuery(Query)
                , mFlags(Flags) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mQueryPool;
        uint32_t mQuery;
        uint32_t mFlags;
    };

    class VkRenderPassBeginInfo__CP: public Encodable {
    public:
        VkRenderPassBeginInfo__CP() = default;
        VkRenderPassBeginInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCmdBeginRenderPass: public Encodable {
    public:
        VkCmdBeginRenderPass() = default;
        VkCmdBeginRenderPass(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, VkRenderPassBeginInfo__CP PRenderPassBegin, uint32_t Contents)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mPRenderPassBegin(PRenderPassBegin)
                , mContents(Contents) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        VkRenderPassBeginInfo__CP mPRenderPassBegin;
        uint32_t mContents;
    };

    class VkDescriptorSet__CP: public Encodable {
    public:
        VkDescriptorSet__CP() = default;
        VkDescriptorSet__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCmdBindDescriptorSets: public Encodable {
    public:
        VkCmdBindDescriptorSets() = default;
        VkCmdBindDescriptorSets(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t PipelineBindPoint, uint64_t Layout, uint32_t FirstSet, uint32_t DescriptorSetCount, VkDescriptorSet__CP PDescriptorSets, uint32_t DynamicOffsetCount, U32__CP PDynamicOffsets)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mPipelineBindPoint(PipelineBindPoint)
                , mLayout(Layout)
                , mFirstSet(FirstSet)
                , mDescriptorSetCount(DescriptorSetCount)
                , mPDescriptorSets(PDescriptorSets)
                , mDynamicOffsetCount(DynamicOffsetCount)
                , mPDynamicOffsets(PDynamicOffsets) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mPipelineBindPoint;
        uint64_t mLayout;
        uint32_t mFirstSet;
        uint32_t mDescriptorSetCount;
        VkDescriptorSet__CP mPDescriptorSets;
        uint32_t mDynamicOffsetCount;
        U32__CP mPDynamicOffsets;
    };

    class VkCmdBindIndexBuffer: public Encodable {
    public:
        VkCmdBindIndexBuffer() = default;
        VkCmdBindIndexBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Buffer, uint64_t Offset, uint32_t IndexType)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mBuffer(Buffer)
                , mOffset(Offset)
                , mIndexType(IndexType) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mBuffer;
        uint64_t mOffset;
        uint32_t mIndexType;
    };

    class VkCmdBindPipeline: public Encodable {
    public:
        VkCmdBindPipeline() = default;
        VkCmdBindPipeline(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t PipelineBindPoint, uint64_t Pipeline)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mPipelineBindPoint(PipelineBindPoint)
                , mPipeline(Pipeline) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mPipelineBindPoint;
        uint64_t mPipeline;
    };

    class VkDeviceSize__CP: public Encodable {
    public:
        VkDeviceSize__CP() = default;
        VkDeviceSize__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCmdBindVertexBuffers: public Encodable {
    public:
        VkCmdBindVertexBuffers() = default;
        VkCmdBindVertexBuffers(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t FirstBinding, uint32_t BindingCount, VkBuffer__CP PBuffers, VkDeviceSize__CP POffsets)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mFirstBinding(FirstBinding)
                , mBindingCount(BindingCount)
                , mPBuffers(PBuffers)
                , mPOffsets(POffsets) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mFirstBinding;
        uint32_t mBindingCount;
        VkBuffer__CP mPBuffers;
        VkDeviceSize__CP mPOffsets;
    };

    class VkImageBlit__CP: public Encodable {
    public:
        VkImageBlit__CP() = default;
        VkImageBlit__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCmdBlitImage: public Encodable {
    public:
        VkCmdBlitImage() = default;
        VkCmdBlitImage(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t SrcImage, uint32_t SrcImageLayout, uint64_t DstImage, uint32_t DstImageLayout, uint32_t RegionCount, VkImageBlit__CP PRegions, uint32_t Filter)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mSrcImage(SrcImage)
                , mSrcImageLayout(SrcImageLayout)
                , mDstImage(DstImage)
                , mDstImageLayout(DstImageLayout)
                , mRegionCount(RegionCount)
                , mPRegions(PRegions)
                , mFilter(Filter) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mSrcImage;
        uint32_t mSrcImageLayout;
        uint64_t mDstImage;
        uint32_t mDstImageLayout;
        uint32_t mRegionCount;
        VkImageBlit__CP mPRegions;
        uint32_t mFilter;
    };

    class VkCmdClearAttachments: public Encodable {
    public:
        VkCmdClearAttachments() = default;
        VkCmdClearAttachments(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t AttachmentCount, VkClearAttachment__CP PAttachments, uint32_t RectCount, VkClearRect__CP PRects)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mAttachmentCount(AttachmentCount)
                , mPAttachments(PAttachments)
                , mRectCount(RectCount)
                , mPRects(PRects) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mAttachmentCount;
        VkClearAttachment__CP mPAttachments;
        uint32_t mRectCount;
        VkClearRect__CP mPRects;
    };

    class VkImageSubresourceRange__CP: public Encodable {
    public:
        VkImageSubresourceRange__CP() = default;
        VkImageSubresourceRange__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCmdClearColorImage: public Encodable {
    public:
        VkCmdClearColorImage() = default;
        VkCmdClearColorImage(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Image, uint32_t ImageLayout, VkClearColorValue__CP PColor, uint32_t RangeCount, VkImageSubresourceRange__CP PRanges)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mImage(Image)
                , mImageLayout(ImageLayout)
                , mPColor(PColor)
                , mRangeCount(RangeCount)
                , mPRanges(PRanges) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mImage;
        uint32_t mImageLayout;
        VkClearColorValue__CP mPColor;
        uint32_t mRangeCount;
        VkImageSubresourceRange__CP mPRanges;
    };

    class VkCmdClearDepthStencilImage: public Encodable {
    public:
        VkCmdClearDepthStencilImage() = default;
        VkCmdClearDepthStencilImage(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Image, uint32_t ImageLayout, VkClearDepthStencilValue__CP PDepthStencil, uint32_t RangeCount, VkImageSubresourceRange__CP PRanges)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mImage(Image)
                , mImageLayout(ImageLayout)
                , mPDepthStencil(PDepthStencil)
                , mRangeCount(RangeCount)
                , mPRanges(PRanges) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mImage;
        uint32_t mImageLayout;
        VkClearDepthStencilValue__CP mPDepthStencil;
        uint32_t mRangeCount;
        VkImageSubresourceRange__CP mPRanges;
    };

    class VkCmdCopyBuffer: public Encodable {
    public:
        VkCmdCopyBuffer() = default;
        VkCmdCopyBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t SrcBuffer, uint64_t DstBuffer, uint32_t RegionCount, VkBufferCopy__CP PRegions)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mSrcBuffer(SrcBuffer)
                , mDstBuffer(DstBuffer)
                , mRegionCount(RegionCount)
                , mPRegions(PRegions) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mSrcBuffer;
        uint64_t mDstBuffer;
        uint32_t mRegionCount;
        VkBufferCopy__CP mPRegions;
    };

    class VkCmdCopyBufferToImage: public Encodable {
    public:
        VkCmdCopyBufferToImage() = default;
        VkCmdCopyBufferToImage(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t SrcBuffer, uint64_t DstImage, uint32_t DstImageLayout, uint32_t RegionCount, VkBufferImageCopy__CP PRegions)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mSrcBuffer(SrcBuffer)
                , mDstImage(DstImage)
                , mDstImageLayout(DstImageLayout)
                , mRegionCount(RegionCount)
                , mPRegions(PRegions) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mSrcBuffer;
        uint64_t mDstImage;
        uint32_t mDstImageLayout;
        uint32_t mRegionCount;
        VkBufferImageCopy__CP mPRegions;
    };

    class VkImageCopy__CP: public Encodable {
    public:
        VkImageCopy__CP() = default;
        VkImageCopy__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCmdCopyImage: public Encodable {
    public:
        VkCmdCopyImage() = default;
        VkCmdCopyImage(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t SrcImage, uint32_t SrcImageLayout, uint64_t DstImage, uint32_t DstImageLayout, uint32_t RegionCount, VkImageCopy__CP PRegions)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mSrcImage(SrcImage)
                , mSrcImageLayout(SrcImageLayout)
                , mDstImage(DstImage)
                , mDstImageLayout(DstImageLayout)
                , mRegionCount(RegionCount)
                , mPRegions(PRegions) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mSrcImage;
        uint32_t mSrcImageLayout;
        uint64_t mDstImage;
        uint32_t mDstImageLayout;
        uint32_t mRegionCount;
        VkImageCopy__CP mPRegions;
    };

    class VkCmdCopyImageToBuffer: public Encodable {
    public:
        VkCmdCopyImageToBuffer() = default;
        VkCmdCopyImageToBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t SrcImage, uint32_t SrcImageLayout, uint64_t DstBuffer, uint32_t RegionCount, VkBufferImageCopy__CP PRegions)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mSrcImage(SrcImage)
                , mSrcImageLayout(SrcImageLayout)
                , mDstBuffer(DstBuffer)
                , mRegionCount(RegionCount)
                , mPRegions(PRegions) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mSrcImage;
        uint32_t mSrcImageLayout;
        uint64_t mDstBuffer;
        uint32_t mRegionCount;
        VkBufferImageCopy__CP mPRegions;
    };

    class VkCmdCopyQueryPoolResults: public Encodable {
    public:
        VkCmdCopyQueryPoolResults() = default;
        VkCmdCopyQueryPoolResults(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t QueryPool, uint32_t FirstQuery, uint32_t QueryCount, uint64_t DstBuffer, uint64_t DstOffset, uint64_t Stride, uint32_t Flags)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mQueryPool(QueryPool)
                , mFirstQuery(FirstQuery)
                , mQueryCount(QueryCount)
                , mDstBuffer(DstBuffer)
                , mDstOffset(DstOffset)
                , mStride(Stride)
                , mFlags(Flags) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mQueryPool;
        uint32_t mFirstQuery;
        uint32_t mQueryCount;
        uint64_t mDstBuffer;
        uint64_t mDstOffset;
        uint64_t mStride;
        uint32_t mFlags;
    };

    class VkCmdDispatch: public Encodable {
    public:
        VkCmdDispatch() = default;
        VkCmdDispatch(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t X, uint32_t Y, uint32_t Z)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mX(X)
                , mY(Y)
                , mZ(Z) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mX;
        uint32_t mY;
        uint32_t mZ;
    };

    class VkCmdDispatchIndirect: public Encodable {
    public:
        VkCmdDispatchIndirect() = default;
        VkCmdDispatchIndirect(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Buffer, uint64_t Offset)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mBuffer(Buffer)
                , mOffset(Offset) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mBuffer;
        uint64_t mOffset;
    };

    class VkCmdDraw: public Encodable {
    public:
        VkCmdDraw() = default;
        VkCmdDraw(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t VertexCount, uint32_t InstanceCount, uint32_t FirstVertex, uint32_t FirstInstance)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mVertexCount(VertexCount)
                , mInstanceCount(InstanceCount)
                , mFirstVertex(FirstVertex)
                , mFirstInstance(FirstInstance) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mVertexCount;
        uint32_t mInstanceCount;
        uint32_t mFirstVertex;
        uint32_t mFirstInstance;
    };

    class VkCmdDrawIndexed: public Encodable {
    public:
        VkCmdDrawIndexed() = default;
        VkCmdDrawIndexed(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t IndexCount, uint32_t InstanceCount, uint32_t FirstIndex, int32_t VertexOffset, uint32_t FirstInstance)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mIndexCount(IndexCount)
                , mInstanceCount(InstanceCount)
                , mFirstIndex(FirstIndex)
                , mVertexOffset(VertexOffset)
                , mFirstInstance(FirstInstance) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mIndexCount;
        uint32_t mInstanceCount;
        uint32_t mFirstIndex;
        int32_t mVertexOffset;
        uint32_t mFirstInstance;
    };

    class VkCmdDrawIndexedIndirect: public Encodable {
    public:
        VkCmdDrawIndexedIndirect() = default;
        VkCmdDrawIndexedIndirect(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Buffer, uint64_t Offset, uint32_t DrawCount, uint32_t Stride)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mBuffer(Buffer)
                , mOffset(Offset)
                , mDrawCount(DrawCount)
                , mStride(Stride) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mBuffer;
        uint64_t mOffset;
        uint32_t mDrawCount;
        uint32_t mStride;
    };

    class VkCmdDrawIndirect: public Encodable {
    public:
        VkCmdDrawIndirect() = default;
        VkCmdDrawIndirect(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Buffer, uint64_t Offset, uint32_t DrawCount, uint32_t Stride)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mBuffer(Buffer)
                , mOffset(Offset)
                , mDrawCount(DrawCount)
                , mStride(Stride) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mBuffer;
        uint64_t mOffset;
        uint32_t mDrawCount;
        uint32_t mStride;
    };

    class VkCmdEndQuery: public Encodable {
    public:
        VkCmdEndQuery() = default;
        VkCmdEndQuery(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t QueryPool, uint32_t Query)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mQueryPool(QueryPool)
                , mQuery(Query) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mQueryPool;
        uint32_t mQuery;
    };

    class VkCmdEndRenderPass: public Encodable {
    public:
        VkCmdEndRenderPass() = default;
        VkCmdEndRenderPass(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mCommandBuffer);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
    };

    class VkCommandBuffer__CP: public Encodable {
    public:
        VkCommandBuffer__CP() = default;
        VkCommandBuffer__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCmdExecuteCommands: public Encodable {
    public:
        VkCmdExecuteCommands() = default;
        VkCmdExecuteCommands(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t CommandBufferCount, VkCommandBuffer__CP PCommandBuffers)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mCommandBufferCount(CommandBufferCount)
                , mPCommandBuffers(PCommandBuffers) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mCommandBufferCount;
        VkCommandBuffer__CP mPCommandBuffers;
    };

    class VkCmdFillBuffer: public Encodable {
    public:
        VkCmdFillBuffer() = default;
        VkCmdFillBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t DstBuffer, uint64_t DstOffset, uint64_t Size, uint32_t Data)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mDstBuffer(DstBuffer)
                , mDstOffset(DstOffset)
                , mSize(Size)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mDstBuffer;
        uint64_t mDstOffset;
        uint64_t mSize;
        uint32_t mData;
    };

    class VkCmdNextSubpass: public Encodable {
    public:
        VkCmdNextSubpass() = default;
        VkCmdNextSubpass(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t Contents)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mContents(Contents) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mCommandBuffer);
            e->Uint32(this->mContents);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mContents;
    };

    class VkMemoryBarrier__CP: public Encodable {
    public:
        VkMemoryBarrier__CP() = default;
        VkMemoryBarrier__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkImageMemoryBarrier__CP: public Encodable {
    public:
        VkImageMemoryBarrier__CP() = default;
        VkImageMemoryBarrier__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCmdPipelineBarrier: public Encodable {
    public:
        VkCmdPipelineBarrier() = default;
        VkCmdPipelineBarrier(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t SrcStageMask, uint32_t DstStageMask, uint32_t DependencyFlags, uint32_t MemoryBarrierCount, VkMemoryBarrier__CP PMemoryBarriers, uint32_t BufferMemoryBarrierCount, VkBufferMemoryBarrier__CP PBufferMemoryBarriers, uint32_t ImageMemoryBarrierCount, VkImageMemoryBarrier__CP PImageMemoryBarriers)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mSrcStageMask(SrcStageMask)
                , mDstStageMask(DstStageMask)
                , mDependencyFlags(DependencyFlags)
                , mMemoryBarrierCount(MemoryBarrierCount)
                , mPMemoryBarriers(PMemoryBarriers)
                , mBufferMemoryBarrierCount(BufferMemoryBarrierCount)
                , mPBufferMemoryBarriers(PBufferMemoryBarriers)
                , mImageMemoryBarrierCount(ImageMemoryBarrierCount)
                , mPImageMemoryBarriers(PImageMemoryBarriers) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mSrcStageMask;
        uint32_t mDstStageMask;
        uint32_t mDependencyFlags;
        uint32_t mMemoryBarrierCount;
        VkMemoryBarrier__CP mPMemoryBarriers;
        uint32_t mBufferMemoryBarrierCount;
        VkBufferMemoryBarrier__CP mPBufferMemoryBarriers;
        uint32_t mImageMemoryBarrierCount;
        VkImageMemoryBarrier__CP mPImageMemoryBarriers;
    };

    class VkCmdPushConstants: public Encodable {
    public:
        VkCmdPushConstants() = default;
        VkCmdPushConstants(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Layout, uint32_t StageFlags, uint32_t Offset, uint32_t Size, Void__CP PValues)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mLayout(Layout)
                , mStageFlags(StageFlags)
                , mOffset(Offset)
                , mSize(Size)
                , mPValues(PValues) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mLayout;
        uint32_t mStageFlags;
        uint32_t mOffset;
        uint32_t mSize;
        Void__CP mPValues;
    };

    class VkCmdResetEvent: public Encodable {
    public:
        VkCmdResetEvent() = default;
        VkCmdResetEvent(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Event, uint32_t StageMask)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mEvent(Event)
                , mStageMask(StageMask) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mEvent;
        uint32_t mStageMask;
    };

    class VkCmdResetQueryPool: public Encodable {
    public:
        VkCmdResetQueryPool() = default;
        VkCmdResetQueryPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t QueryPool, uint32_t FirstQuery, uint32_t QueryCount)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mQueryPool(QueryPool)
                , mFirstQuery(FirstQuery)
                , mQueryCount(QueryCount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mQueryPool;
        uint32_t mFirstQuery;
        uint32_t mQueryCount;
    };

    class VkImageResolve__CP: public Encodable {
    public:
        VkImageResolve__CP() = default;
        VkImageResolve__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCmdResolveImage: public Encodable {
    public:
        VkCmdResolveImage() = default;
        VkCmdResolveImage(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t SrcImage, uint32_t SrcImageLayout, uint64_t DstImage, uint32_t DstImageLayout, uint32_t RegionCount, VkImageResolve__CP PRegions)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mSrcImage(SrcImage)
                , mSrcImageLayout(SrcImageLayout)
                , mDstImage(DstImage)
                , mDstImageLayout(DstImageLayout)
                , mRegionCount(RegionCount)
                , mPRegions(PRegions) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mSrcImage;
        uint32_t mSrcImageLayout;
        uint64_t mDstImage;
        uint32_t mDstImageLayout;
        uint32_t mRegionCount;
        VkImageResolve__CP mPRegions;
    };

    class VkCmdSetBlendConstants: public Encodable {
    public:
        VkCmdSetBlendConstants() = default;
        VkCmdSetBlendConstants(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, F32__4__A BlendConstants)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mBlendConstants(BlendConstants) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mCommandBuffer);
            e->Struct(this->mBlendConstants);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        F32__4__A mBlendConstants;
    };

    class VkCmdSetDepthBias: public Encodable {
    public:
        VkCmdSetDepthBias() = default;
        VkCmdSetDepthBias(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, float DepthBiasConstantFactor, float DepthBiasClamp, float DepthBiasSlopeFactor)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mDepthBiasConstantFactor(DepthBiasConstantFactor)
                , mDepthBiasClamp(DepthBiasClamp)
                , mDepthBiasSlopeFactor(DepthBiasSlopeFactor) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        float mDepthBiasConstantFactor;
        float mDepthBiasClamp;
        float mDepthBiasSlopeFactor;
    };

    class VkCmdSetDepthBounds: public Encodable {
    public:
        VkCmdSetDepthBounds() = default;
        VkCmdSetDepthBounds(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, float MinDepthBounds, float MaxDepthBounds)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mMinDepthBounds(MinDepthBounds)
                , mMaxDepthBounds(MaxDepthBounds) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        float mMinDepthBounds;
        float mMaxDepthBounds;
    };

    class VkCmdSetEvent: public Encodable {
    public:
        VkCmdSetEvent() = default;
        VkCmdSetEvent(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Event, uint32_t StageMask)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mEvent(Event)
                , mStageMask(StageMask) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mEvent;
        uint32_t mStageMask;
    };

    class VkCmdSetLineWidth: public Encodable {
    public:
        VkCmdSetLineWidth() = default;
        VkCmdSetLineWidth(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, float LineWidth)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mLineWidth(LineWidth) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mCommandBuffer);
            e->Float32(this->mLineWidth);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        float mLineWidth;
    };

    class VkRect2D__CP: public Encodable {
    public:
        VkRect2D__CP() = default;
        VkRect2D__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCmdSetScissor: public Encodable {
    public:
        VkCmdSetScissor() = default;
        VkCmdSetScissor(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t FirstScissor, uint32_t ScissorCount, VkRect2D__CP PScissors)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mFirstScissor(FirstScissor)
                , mScissorCount(ScissorCount)
                , mPScissors(PScissors) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mFirstScissor;
        uint32_t mScissorCount;
        VkRect2D__CP mPScissors;
    };

    class VkCmdSetStencilCompareMask: public Encodable {
    public:
        VkCmdSetStencilCompareMask() = default;
        VkCmdSetStencilCompareMask(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t FaceMask, uint32_t CompareMask)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mFaceMask(FaceMask)
                , mCompareMask(CompareMask) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mFaceMask;
        uint32_t mCompareMask;
    };

    class VkCmdSetStencilReference: public Encodable {
    public:
        VkCmdSetStencilReference() = default;
        VkCmdSetStencilReference(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t FaceMask, uint32_t Reference)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mFaceMask(FaceMask)
                , mReference(Reference) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mFaceMask;
        uint32_t mReference;
    };

    class VkCmdSetStencilWriteMask: public Encodable {
    public:
        VkCmdSetStencilWriteMask() = default;
        VkCmdSetStencilWriteMask(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t FaceMask, uint32_t WriteMask)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mFaceMask(FaceMask)
                , mWriteMask(WriteMask) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mFaceMask;
        uint32_t mWriteMask;
    };

    class VkViewport__CP: public Encodable {
    public:
        VkViewport__CP() = default;
        VkViewport__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCmdSetViewport: public Encodable {
    public:
        VkCmdSetViewport() = default;
        VkCmdSetViewport(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t FirstViewport, uint32_t ViewportCount, VkViewport__CP PViewports)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mFirstViewport(FirstViewport)
                , mViewportCount(ViewportCount)
                , mPViewports(PViewports) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mFirstViewport;
        uint32_t mViewportCount;
        VkViewport__CP mPViewports;
    };

    class VkCmdUpdateBuffer: public Encodable {
    public:
        VkCmdUpdateBuffer() = default;
        VkCmdUpdateBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t DstBuffer, uint64_t DstOffset, uint64_t DataSize, U32__CP PData)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mDstBuffer(DstBuffer)
                , mDstOffset(DstOffset)
                , mDataSize(DataSize)
                , mPData(PData) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint64_t mDstBuffer;
        uint64_t mDstOffset;
        uint64_t mDataSize;
        U32__CP mPData;
    };

    class VkEvent__CP: public Encodable {
    public:
        VkEvent__CP() = default;
        VkEvent__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCmdWaitEvents: public Encodable {
    public:
        VkCmdWaitEvents() = default;
        VkCmdWaitEvents(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t EventCount, VkEvent__CP PEvents, uint32_t SrcStageMask, uint32_t DstStageMask, uint32_t MemoryBarrierCount, VkMemoryBarrier__CP PMemoryBarriers, uint32_t BufferMemoryBarrierCount, VkBufferMemoryBarrier__CP PBufferMemoryBarriers, uint32_t ImageMemoryBarrierCount, VkImageMemoryBarrier__CP PImageMemoryBarriers)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mEventCount(EventCount)
                , mPEvents(PEvents)
                , mSrcStageMask(SrcStageMask)
                , mDstStageMask(DstStageMask)
                , mMemoryBarrierCount(MemoryBarrierCount)
                , mPMemoryBarriers(PMemoryBarriers)
                , mBufferMemoryBarrierCount(BufferMemoryBarrierCount)
                , mPBufferMemoryBarriers(PBufferMemoryBarriers)
                , mImageMemoryBarrierCount(ImageMemoryBarrierCount)
                , mPImageMemoryBarriers(PImageMemoryBarriers) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mEventCount;
        VkEvent__CP mPEvents;
        uint32_t mSrcStageMask;
        uint32_t mDstStageMask;
        uint32_t mMemoryBarrierCount;
        VkMemoryBarrier__CP mPMemoryBarriers;
        uint32_t mBufferMemoryBarrierCount;
        VkBufferMemoryBarrier__CP mPBufferMemoryBarriers;
        uint32_t mImageMemoryBarrierCount;
        VkImageMemoryBarrier__CP mPImageMemoryBarriers;
    };

    class VkCmdWriteTimestamp: public Encodable {
    public:
        VkCmdWriteTimestamp() = default;
        VkCmdWriteTimestamp(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t PipelineStage, uint64_t QueryPool, uint32_t Query)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mPipelineStage(PipelineStage)
                , mQueryPool(QueryPool)
                , mQuery(Query) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mPipelineStage;
        uint64_t mQueryPool;
        uint32_t mQuery;
    };

    class VkCommandBufferAllocateInfo: public Encodable {
    public:
        VkCommandBufferAllocateInfo() = default;
        VkCommandBufferAllocateInfo(uint32_t SType, Void__CP PNext, uint64_t CommandPool, uint32_t Level, uint32_t CommandBufferCount)
                : mSType(SType)
                , mPNext(PNext)
                , mCommandPool(CommandPool)
                , mLevel(Level)
                , mCommandBufferCount(CommandBufferCount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint64_t mCommandPool;
        uint32_t mLevel;
        uint32_t mCommandBufferCount;
    };

    class VkCommandBufferAllocateInfo__S: public Encodable {
    public:
        VkCommandBufferAllocateInfo__S() = default;
        VkCommandBufferAllocateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkCommandBufferAllocateInfo__P: public Encodable {
    public:
        VkCommandBufferAllocateInfo__P() = default;
        VkCommandBufferAllocateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCommandBufferInheritanceInfo__CP: public Encodable {
    public:
        VkCommandBufferInheritanceInfo__CP() = default;
        VkCommandBufferInheritanceInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCommandBufferBeginInfo: public Encodable {
    public:
        VkCommandBufferBeginInfo() = default;
        VkCommandBufferBeginInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, VkCommandBufferInheritanceInfo__CP PInheritanceInfo)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mPInheritanceInfo(PInheritanceInfo) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        VkCommandBufferInheritanceInfo__CP mPInheritanceInfo;
    };

    class VkCommandBufferBeginInfo__S: public Encodable {
    public:
        VkCommandBufferBeginInfo__S() = default;
        VkCommandBufferBeginInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkCommandBufferBeginInfo__P: public Encodable {
    public:
        VkCommandBufferBeginInfo__P() = default;
        VkCommandBufferBeginInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCommandBufferInheritanceInfo: public Encodable {
    public:
        VkCommandBufferInheritanceInfo() = default;
        VkCommandBufferInheritanceInfo(uint32_t SType, Void__CP PNext, uint64_t RenderPass, uint32_t Subpass, uint64_t Framebuffer, uint32_t OcclusionQueryEnable, uint32_t QueryFlags, uint32_t PipelineStatistics)
                : mSType(SType)
                , mPNext(PNext)
                , mRenderPass(RenderPass)
                , mSubpass(Subpass)
                , mFramebuffer(Framebuffer)
                , mOcclusionQueryEnable(OcclusionQueryEnable)
                , mQueryFlags(QueryFlags)
                , mPipelineStatistics(PipelineStatistics) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint64_t mRenderPass;
        uint32_t mSubpass;
        uint64_t mFramebuffer;
        uint32_t mOcclusionQueryEnable;
        uint32_t mQueryFlags;
        uint32_t mPipelineStatistics;
    };

    class VkCommandBufferInheritanceInfo__S: public Encodable {
    public:
        VkCommandBufferInheritanceInfo__S() = default;
        VkCommandBufferInheritanceInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkCommandBufferInheritanceInfo__P: public Encodable {
    public:
        VkCommandBufferInheritanceInfo__P() = default;
        VkCommandBufferInheritanceInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCommandBuffer__S: public Encodable {
    public:
        VkCommandBuffer__S() = default;
        VkCommandBuffer__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkCommandPoolCreateInfo: public Encodable {
    public:
        VkCommandPoolCreateInfo() = default;
        VkCommandPoolCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t QueueFamilyIndex)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mQueueFamilyIndex(QueueFamilyIndex) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mQueueFamilyIndex;
    };

    class VkCommandPoolCreateInfo__S: public Encodable {
    public:
        VkCommandPoolCreateInfo__S() = default;
        VkCommandPoolCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkCommandPoolCreateInfo__P: public Encodable {
    public:
        VkCommandPoolCreateInfo__P() = default;
        VkCommandPoolCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCommandPoolCreateInfo__CP: public Encodable {
    public:
        VkCommandPoolCreateInfo__CP() = default;
        VkCommandPoolCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCommandPool__S: public Encodable {
    public:
        VkCommandPool__S() = default;
        VkCommandPool__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkCommandPool__P: public Encodable {
    public:
        VkCommandPool__P() = default;
        VkCommandPool__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkComponentMapping: public Encodable {
    public:
        VkComponentMapping() = default;
        VkComponentMapping(uint32_t R, uint32_t G, uint32_t B, uint32_t A)
                : mR(R)
                , mG(G)
                , mB(B)
                , mA(A) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mR;
        uint32_t mG;
        uint32_t mB;
        uint32_t mA;
    };

    class VkSpecializationInfo__CP: public Encodable {
    public:
        VkSpecializationInfo__CP() = default;
        VkSpecializationInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineShaderStageCreateInfo: public Encodable {
    public:
        VkPipelineShaderStageCreateInfo() = default;
        VkPipelineShaderStageCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t Stage, uint64_t Module, Char__CP PName, VkSpecializationInfo__CP PSpecializationInfo)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mStage(Stage)
                , mModule(Module)
                , mPName(PName)
                , mPSpecializationInfo(PSpecializationInfo) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mStage;
        uint64_t mModule;
        Char__CP mPName;
        VkSpecializationInfo__CP mPSpecializationInfo;
    };

    class VkComputePipelineCreateInfo: public Encodable {
    public:
        VkComputePipelineCreateInfo() = default;
        VkComputePipelineCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, VkPipelineShaderStageCreateInfo Stage, uint64_t Layout, uint64_t BasePipelineHandle, int32_t BasePipelineIndex)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mStage(Stage)
                , mLayout(Layout)
                , mBasePipelineHandle(BasePipelineHandle)
                , mBasePipelineIndex(BasePipelineIndex) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        VkPipelineShaderStageCreateInfo mStage;
        uint64_t mLayout;
        uint64_t mBasePipelineHandle;
        int32_t mBasePipelineIndex;
    };

    class VkComputePipelineCreateInfo__S: public Encodable {
    public:
        VkComputePipelineCreateInfo__S() = default;
        VkComputePipelineCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkComputePipelineCreateInfo__P: public Encodable {
    public:
        VkComputePipelineCreateInfo__P() = default;
        VkComputePipelineCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkComputePipelineCreateInfo__CP: public Encodable {
    public:
        VkComputePipelineCreateInfo__CP() = default;
        VkComputePipelineCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCopyDescriptorSet: public Encodable {
    public:
        VkCopyDescriptorSet() = default;
        VkCopyDescriptorSet(uint32_t SType, Void__CP PNext, uint64_t SrcSet, uint32_t SrcBinding, uint32_t SrcArrayElement, uint64_t DstSet, uint32_t DstBinding, uint32_t DstArrayElement, uint32_t DescriptorCount)
                : mSType(SType)
                , mPNext(PNext)
                , mSrcSet(SrcSet)
                , mSrcBinding(SrcBinding)
                , mSrcArrayElement(SrcArrayElement)
                , mDstSet(DstSet)
                , mDstBinding(DstBinding)
                , mDstArrayElement(DstArrayElement)
                , mDescriptorCount(DescriptorCount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint64_t mSrcSet;
        uint32_t mSrcBinding;
        uint32_t mSrcArrayElement;
        uint64_t mDstSet;
        uint32_t mDstBinding;
        uint32_t mDstArrayElement;
        uint32_t mDescriptorCount;
    };

    class VkCopyDescriptorSet__S: public Encodable {
    public:
        VkCopyDescriptorSet__S() = default;
        VkCopyDescriptorSet__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkCopyDescriptorSet__P: public Encodable {
    public:
        VkCopyDescriptorSet__P() = default;
        VkCopyDescriptorSet__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCopyDescriptorSet__CP: public Encodable {
    public:
        VkCopyDescriptorSet__CP() = default;
        VkCopyDescriptorSet__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSurfaceKHR__P: public Encodable {
    public:
        VkSurfaceKHR__P() = default;
        VkSurfaceKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateAndroidSurfaceKHR: public Encodable {
    public:
        VkCreateAndroidSurfaceKHR() = default;
        VkCreateAndroidSurfaceKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, VkAndroidSurfaceCreateInfoKHR__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSurfaceKHR__P PSurface, uint32_t Result)
                : mextras(extras)
                , mInstance(Instance)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPSurface(PSurface)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mInstance;
        VkAndroidSurfaceCreateInfoKHR__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkSurfaceKHR__P mPSurface;
        uint32_t mResult;
    };

    class VkCreateBuffer: public Encodable {
    public:
        VkCreateBuffer() = default;
        VkCreateBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkBufferCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkBuffer__P PBuffer, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPBuffer(PBuffer)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkBufferCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkBuffer__P mPBuffer;
        uint32_t mResult;
    };

    class VkCreateBufferView: public Encodable {
    public:
        VkCreateBufferView() = default;
        VkCreateBufferView(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkBufferViewCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkBufferView__P PView, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPView(PView)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkBufferViewCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkBufferView__P mPView;
        uint32_t mResult;
    };

    class VkCreateCommandPool: public Encodable {
    public:
        VkCreateCommandPool() = default;
        VkCreateCommandPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkCommandPoolCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkCommandPool__P PCommandPool, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPCommandPool(PCommandPool)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkCommandPoolCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkCommandPool__P mPCommandPool;
        uint32_t mResult;
    };

    class VkPipeline__P: public Encodable {
    public:
        VkPipeline__P() = default;
        VkPipeline__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateComputePipelines: public Encodable {
    public:
        VkCreateComputePipelines() = default;
        VkCreateComputePipelines(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t PipelineCache, uint32_t CreateInfoCount, VkComputePipelineCreateInfo__CP PCreateInfos, VkAllocationCallbacks__CP PAllocator, VkPipeline__P PPipelines, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPipelineCache(PipelineCache)
                , mCreateInfoCount(CreateInfoCount)
                , mPCreateInfos(PCreateInfos)
                , mPAllocator(PAllocator)
                , mPPipelines(PPipelines)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mPipelineCache;
        uint32_t mCreateInfoCount;
        VkComputePipelineCreateInfo__CP mPCreateInfos;
        VkAllocationCallbacks__CP mPAllocator;
        VkPipeline__P mPPipelines;
        uint32_t mResult;
    };

    class VkDebugReportCallbackCreateInfoEXT__CP: public Encodable {
    public:
        VkDebugReportCallbackCreateInfoEXT__CP() = default;
        VkDebugReportCallbackCreateInfoEXT__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDebugReportCallbackEXT__P: public Encodable {
    public:
        VkDebugReportCallbackEXT__P() = default;
        VkDebugReportCallbackEXT__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateDebugReportCallbackEXT: public Encodable {
    public:
        VkCreateDebugReportCallbackEXT() = default;
        VkCreateDebugReportCallbackEXT(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, VkDebugReportCallbackCreateInfoEXT__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkDebugReportCallbackEXT__P PCallback, uint32_t Result)
                : mextras(extras)
                , mInstance(Instance)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPCallback(PCallback)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mInstance;
        VkDebugReportCallbackCreateInfoEXT__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkDebugReportCallbackEXT__P mPCallback;
        uint32_t mResult;
    };

    class VkDescriptorPoolCreateInfo__CP: public Encodable {
    public:
        VkDescriptorPoolCreateInfo__CP() = default;
        VkDescriptorPoolCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDescriptorPool__P: public Encodable {
    public:
        VkDescriptorPool__P() = default;
        VkDescriptorPool__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateDescriptorPool: public Encodable {
    public:
        VkCreateDescriptorPool() = default;
        VkCreateDescriptorPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkDescriptorPoolCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkDescriptorPool__P PDescriptorPool, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPDescriptorPool(PDescriptorPool)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkDescriptorPoolCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkDescriptorPool__P mPDescriptorPool;
        uint32_t mResult;
    };

    class VkDescriptorSetLayoutCreateInfo__CP: public Encodable {
    public:
        VkDescriptorSetLayoutCreateInfo__CP() = default;
        VkDescriptorSetLayoutCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDescriptorSetLayout__P: public Encodable {
    public:
        VkDescriptorSetLayout__P() = default;
        VkDescriptorSetLayout__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateDescriptorSetLayout: public Encodable {
    public:
        VkCreateDescriptorSetLayout() = default;
        VkCreateDescriptorSetLayout(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkDescriptorSetLayoutCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkDescriptorSetLayout__P PSetLayout, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPSetLayout(PSetLayout)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkDescriptorSetLayoutCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkDescriptorSetLayout__P mPSetLayout;
        uint32_t mResult;
    };

    class VkCreateDevice: public Encodable {
    public:
        VkCreateDevice() = default;
        VkCreateDevice(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, VkDeviceCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkDevice__P PDevice, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPDevice(PDevice)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        VkDeviceCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkDevice__P mPDevice;
        uint32_t mResult;
    };

    class VkDisplayModeCreateInfoKHR__CP: public Encodable {
    public:
        VkDisplayModeCreateInfoKHR__CP() = default;
        VkDisplayModeCreateInfoKHR__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDisplayModeKHR__P: public Encodable {
    public:
        VkDisplayModeKHR__P() = default;
        VkDisplayModeKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateDisplayModeKHR: public Encodable {
    public:
        VkCreateDisplayModeKHR() = default;
        VkCreateDisplayModeKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint64_t Display, VkDisplayModeCreateInfoKHR__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkDisplayModeKHR__P PMode, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mDisplay(Display)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPMode(PMode)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        uint64_t mDisplay;
        VkDisplayModeCreateInfoKHR__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkDisplayModeKHR__P mPMode;
        uint32_t mResult;
    };

    class VkDisplaySurfaceCreateInfoKHR__CP: public Encodable {
    public:
        VkDisplaySurfaceCreateInfoKHR__CP() = default;
        VkDisplaySurfaceCreateInfoKHR__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateDisplayPlaneSurfaceKHR: public Encodable {
    public:
        VkCreateDisplayPlaneSurfaceKHR() = default;
        VkCreateDisplayPlaneSurfaceKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, VkDisplaySurfaceCreateInfoKHR__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSurfaceKHR__P PSurface, uint32_t Result)
                : mextras(extras)
                , mInstance(Instance)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPSurface(PSurface)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mInstance;
        VkDisplaySurfaceCreateInfoKHR__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkSurfaceKHR__P mPSurface;
        uint32_t mResult;
    };

    class VkEventCreateInfo__CP: public Encodable {
    public:
        VkEventCreateInfo__CP() = default;
        VkEventCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkEvent__P: public Encodable {
    public:
        VkEvent__P() = default;
        VkEvent__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateEvent: public Encodable {
    public:
        VkCreateEvent() = default;
        VkCreateEvent(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkEventCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkEvent__P PEvent, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPEvent(PEvent)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkEventCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkEvent__P mPEvent;
        uint32_t mResult;
    };

    class VkFenceCreateInfo__CP: public Encodable {
    public:
        VkFenceCreateInfo__CP() = default;
        VkFenceCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkFence__P: public Encodable {
    public:
        VkFence__P() = default;
        VkFence__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateFence: public Encodable {
    public:
        VkCreateFence() = default;
        VkCreateFence(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkFenceCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkFence__P PFence, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPFence(PFence)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkFenceCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkFence__P mPFence;
        uint32_t mResult;
    };

    class VkFramebufferCreateInfo__CP: public Encodable {
    public:
        VkFramebufferCreateInfo__CP() = default;
        VkFramebufferCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkFramebuffer__P: public Encodable {
    public:
        VkFramebuffer__P() = default;
        VkFramebuffer__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateFramebuffer: public Encodable {
    public:
        VkCreateFramebuffer() = default;
        VkCreateFramebuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkFramebufferCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkFramebuffer__P PFramebuffer, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPFramebuffer(PFramebuffer)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkFramebufferCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkFramebuffer__P mPFramebuffer;
        uint32_t mResult;
    };

    class VkGraphicsPipelineCreateInfo__CP: public Encodable {
    public:
        VkGraphicsPipelineCreateInfo__CP() = default;
        VkGraphicsPipelineCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateGraphicsPipelines: public Encodable {
    public:
        VkCreateGraphicsPipelines() = default;
        VkCreateGraphicsPipelines(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t PipelineCache, uint32_t CreateInfoCount, VkGraphicsPipelineCreateInfo__CP PCreateInfos, VkAllocationCallbacks__CP PAllocator, VkPipeline__P PPipelines, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPipelineCache(PipelineCache)
                , mCreateInfoCount(CreateInfoCount)
                , mPCreateInfos(PCreateInfos)
                , mPAllocator(PAllocator)
                , mPPipelines(PPipelines)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mPipelineCache;
        uint32_t mCreateInfoCount;
        VkGraphicsPipelineCreateInfo__CP mPCreateInfos;
        VkAllocationCallbacks__CP mPAllocator;
        VkPipeline__P mPPipelines;
        uint32_t mResult;
    };

    class VkImageCreateInfo__CP: public Encodable {
    public:
        VkImageCreateInfo__CP() = default;
        VkImageCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkImage__P: public Encodable {
    public:
        VkImage__P() = default;
        VkImage__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateImage: public Encodable {
    public:
        VkCreateImage() = default;
        VkCreateImage(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkImageCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkImage__P PImage, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPImage(PImage)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkImageCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkImage__P mPImage;
        uint32_t mResult;
    };

    class VkImageViewCreateInfo__CP: public Encodable {
    public:
        VkImageViewCreateInfo__CP() = default;
        VkImageViewCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkImageView__P: public Encodable {
    public:
        VkImageView__P() = default;
        VkImageView__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateImageView: public Encodable {
    public:
        VkCreateImageView() = default;
        VkCreateImageView(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkImageViewCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkImageView__P PView, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPView(PView)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkImageViewCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkImageView__P mPView;
        uint32_t mResult;
    };

    class VkCreateInstance: public Encodable {
    public:
        VkCreateInstance() = default;
        VkCreateInstance(const gapic::Vector<gapic::Encodable*>& extras, VkInstanceCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkInstance__P PInstance, uint32_t Result)
                : mextras(extras)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPInstance(PInstance)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        VkInstanceCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkInstance__P mPInstance;
        uint32_t mResult;
    };

    class VkMirSurfaceCreateInfoKHR__CP: public Encodable {
    public:
        VkMirSurfaceCreateInfoKHR__CP() = default;
        VkMirSurfaceCreateInfoKHR__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateMirSurfaceKHR: public Encodable {
    public:
        VkCreateMirSurfaceKHR() = default;
        VkCreateMirSurfaceKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, VkMirSurfaceCreateInfoKHR__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSurfaceKHR__P PSurface, uint32_t Result)
                : mextras(extras)
                , mInstance(Instance)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPSurface(PSurface)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mInstance;
        VkMirSurfaceCreateInfoKHR__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkSurfaceKHR__P mPSurface;
        uint32_t mResult;
    };

    class VkPipelineCacheCreateInfo__CP: public Encodable {
    public:
        VkPipelineCacheCreateInfo__CP() = default;
        VkPipelineCacheCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineCache__P: public Encodable {
    public:
        VkPipelineCache__P() = default;
        VkPipelineCache__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreatePipelineCache: public Encodable {
    public:
        VkCreatePipelineCache() = default;
        VkCreatePipelineCache(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkPipelineCacheCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkPipelineCache__P PPipelineCache, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPPipelineCache(PPipelineCache)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkPipelineCacheCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkPipelineCache__P mPPipelineCache;
        uint32_t mResult;
    };

    class VkPipelineLayoutCreateInfo__CP: public Encodable {
    public:
        VkPipelineLayoutCreateInfo__CP() = default;
        VkPipelineLayoutCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineLayout__P: public Encodable {
    public:
        VkPipelineLayout__P() = default;
        VkPipelineLayout__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreatePipelineLayout: public Encodable {
    public:
        VkCreatePipelineLayout() = default;
        VkCreatePipelineLayout(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkPipelineLayoutCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkPipelineLayout__P PPipelineLayout, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPPipelineLayout(PPipelineLayout)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkPipelineLayoutCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkPipelineLayout__P mPPipelineLayout;
        uint32_t mResult;
    };

    class VkQueryPoolCreateInfo__CP: public Encodable {
    public:
        VkQueryPoolCreateInfo__CP() = default;
        VkQueryPoolCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkQueryPool__P: public Encodable {
    public:
        VkQueryPool__P() = default;
        VkQueryPool__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateQueryPool: public Encodable {
    public:
        VkCreateQueryPool() = default;
        VkCreateQueryPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkQueryPoolCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkQueryPool__P PQueryPool, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPQueryPool(PQueryPool)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkQueryPoolCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkQueryPool__P mPQueryPool;
        uint32_t mResult;
    };

    class VkRenderPassCreateInfo__CP: public Encodable {
    public:
        VkRenderPassCreateInfo__CP() = default;
        VkRenderPassCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkRenderPass__P: public Encodable {
    public:
        VkRenderPass__P() = default;
        VkRenderPass__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateRenderPass: public Encodable {
    public:
        VkCreateRenderPass() = default;
        VkCreateRenderPass(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkRenderPassCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkRenderPass__P PRenderPass, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPRenderPass(PRenderPass)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkRenderPassCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkRenderPass__P mPRenderPass;
        uint32_t mResult;
    };

    class VkSamplerCreateInfo__CP: public Encodable {
    public:
        VkSamplerCreateInfo__CP() = default;
        VkSamplerCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSampler__P: public Encodable {
    public:
        VkSampler__P() = default;
        VkSampler__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateSampler: public Encodable {
    public:
        VkCreateSampler() = default;
        VkCreateSampler(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkSamplerCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSampler__P PSampler, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPSampler(PSampler)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkSamplerCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkSampler__P mPSampler;
        uint32_t mResult;
    };

    class VkSemaphoreCreateInfo__CP: public Encodable {
    public:
        VkSemaphoreCreateInfo__CP() = default;
        VkSemaphoreCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSemaphore__P: public Encodable {
    public:
        VkSemaphore__P() = default;
        VkSemaphore__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateSemaphore: public Encodable {
    public:
        VkCreateSemaphore() = default;
        VkCreateSemaphore(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkSemaphoreCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSemaphore__P PSemaphore, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPSemaphore(PSemaphore)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkSemaphoreCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkSemaphore__P mPSemaphore;
        uint32_t mResult;
    };

    class VkShaderModuleCreateInfo__CP: public Encodable {
    public:
        VkShaderModuleCreateInfo__CP() = default;
        VkShaderModuleCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkShaderModule__P: public Encodable {
    public:
        VkShaderModule__P() = default;
        VkShaderModule__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateShaderModule: public Encodable {
    public:
        VkCreateShaderModule() = default;
        VkCreateShaderModule(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkShaderModuleCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkShaderModule__P PShaderModule, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPShaderModule(PShaderModule)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkShaderModuleCreateInfo__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkShaderModule__P mPShaderModule;
        uint32_t mResult;
    };

    class VkSwapchainCreateInfoKHR__CP: public Encodable {
    public:
        VkSwapchainCreateInfoKHR__CP() = default;
        VkSwapchainCreateInfoKHR__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateSharedSwapchainsKHR: public Encodable {
    public:
        VkCreateSharedSwapchainsKHR() = default;
        VkCreateSharedSwapchainsKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t SwapchainCount, VkSwapchainCreateInfoKHR__CP PCreateInfos, VkAllocationCallbacks__CP PAllocator, VkSwapchainKHR__P PSwapchains, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mSwapchainCount(SwapchainCount)
                , mPCreateInfos(PCreateInfos)
                , mPAllocator(PAllocator)
                , mPSwapchains(PSwapchains)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint32_t mSwapchainCount;
        VkSwapchainCreateInfoKHR__CP mPCreateInfos;
        VkAllocationCallbacks__CP mPAllocator;
        VkSwapchainKHR__P mPSwapchains;
        uint32_t mResult;
    };

    class VkCreateSwapchainKHR: public Encodable {
    public:
        VkCreateSwapchainKHR() = default;
        VkCreateSwapchainKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkSwapchainCreateInfoKHR__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSwapchainKHR__P PSwapchain, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPSwapchain(PSwapchain)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkSwapchainCreateInfoKHR__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkSwapchainKHR__P mPSwapchain;
        uint32_t mResult;
    };

    class VkWaylandSurfaceCreateInfoKHR__CP: public Encodable {
    public:
        VkWaylandSurfaceCreateInfoKHR__CP() = default;
        VkWaylandSurfaceCreateInfoKHR__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateWaylandSurfaceKHR: public Encodable {
    public:
        VkCreateWaylandSurfaceKHR() = default;
        VkCreateWaylandSurfaceKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, VkWaylandSurfaceCreateInfoKHR__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSurfaceKHR__P PSurface, uint32_t Result)
                : mextras(extras)
                , mInstance(Instance)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPSurface(PSurface)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mInstance;
        VkWaylandSurfaceCreateInfoKHR__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkSurfaceKHR__P mPSurface;
        uint32_t mResult;
    };

    class VkXcbSurfaceCreateInfoKHR__CP: public Encodable {
    public:
        VkXcbSurfaceCreateInfoKHR__CP() = default;
        VkXcbSurfaceCreateInfoKHR__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateXcbSurfaceKHR: public Encodable {
    public:
        VkCreateXcbSurfaceKHR() = default;
        VkCreateXcbSurfaceKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, VkXcbSurfaceCreateInfoKHR__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSurfaceKHR__P PSurface, uint32_t Result)
                : mextras(extras)
                , mInstance(Instance)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPSurface(PSurface)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mInstance;
        VkXcbSurfaceCreateInfoKHR__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkSurfaceKHR__P mPSurface;
        uint32_t mResult;
    };

    class VkXlibSurfaceCreateInfoKHR__CP: public Encodable {
    public:
        VkXlibSurfaceCreateInfoKHR__CP() = default;
        VkXlibSurfaceCreateInfoKHR__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkCreateXlibSurfaceKHR: public Encodable {
    public:
        VkCreateXlibSurfaceKHR() = default;
        VkCreateXlibSurfaceKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, VkXlibSurfaceCreateInfoKHR__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSurfaceKHR__P PSurface, uint32_t Result)
                : mextras(extras)
                , mInstance(Instance)
                , mPCreateInfo(PCreateInfo)
                , mPAllocator(PAllocator)
                , mPSurface(PSurface)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mInstance;
        VkXlibSurfaceCreateInfoKHR__CP mPCreateInfo;
        VkAllocationCallbacks__CP mPAllocator;
        VkSurfaceKHR__P mPSurface;
        uint32_t mResult;
    };

    class VkDebugReportCallbackCreateInfoEXT: public Encodable {
    public:
        VkDebugReportCallbackCreateInfoEXT() = default;
        VkDebugReportCallbackCreateInfoEXT(uint32_t SType, Void__CP PNext, uint32_t Flags, PFN_vkDebugReportCallbackEXT PfnCallback, Void__P PUserData)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mPfnCallback(PfnCallback)
                , mPUserData(PUserData) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        PFN_vkDebugReportCallbackEXT mPfnCallback;
        Void__P mPUserData;
    };

    class VkDebugReportCallbackCreateInfoEXT__S: public Encodable {
    public:
        VkDebugReportCallbackCreateInfoEXT__S() = default;
        VkDebugReportCallbackCreateInfoEXT__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDebugReportCallbackCreateInfoEXT__P: public Encodable {
    public:
        VkDebugReportCallbackCreateInfoEXT__P() = default;
        VkDebugReportCallbackCreateInfoEXT__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDebugReportCallbackEXT__S: public Encodable {
    public:
        VkDebugReportCallbackEXT__S() = default;
        VkDebugReportCallbackEXT__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDebugReportMessageEXT: public Encodable {
    public:
        VkDebugReportMessageEXT() = default;
        VkDebugReportMessageEXT(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, uint32_t Flags, uint32_t ObjectType, uint64_t Object, uint64_t Location, int32_t MessageCode, const char* PLayerPrefix, const char* PMessage)
                : mextras(extras)
                , mInstance(Instance)
                , mFlags(Flags)
                , mObjectType(ObjectType)
                , mObject(Object)
                , mLocation(Location)
                , mMessageCode(MessageCode)
                , mPLayerPrefix(PLayerPrefix)
                , mPMessage(PMessage) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mInstance;
        uint32_t mFlags;
        uint32_t mObjectType;
        uint64_t mObject;
        uint64_t mLocation;
        int32_t mMessageCode;
        const char* mPLayerPrefix;
        const char* mPMessage;
    };

    class VkDescriptorBufferInfo__S: public Encodable {
    public:
        VkDescriptorBufferInfo__S() = default;
        VkDescriptorBufferInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDescriptorBufferInfo__P: public Encodable {
    public:
        VkDescriptorBufferInfo__P() = default;
        VkDescriptorBufferInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDescriptorBufferInfo__CP: public Encodable {
    public:
        VkDescriptorBufferInfo__CP() = default;
        VkDescriptorBufferInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDescriptorImageInfo: public Encodable {
    public:
        VkDescriptorImageInfo() = default;
        VkDescriptorImageInfo(uint64_t Sampler, uint64_t ImageView, uint32_t ImageLayout)
                : mSampler(Sampler)
                , mImageView(ImageView)
                , mImageLayout(ImageLayout) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mSampler);
            e->Uint64(this->mImageView);
            e->Uint32(this->mImageLayout);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mSampler;
        uint64_t mImageView;
        uint32_t mImageLayout;
    };

    class VkDescriptorImageInfo__S: public Encodable {
    public:
        VkDescriptorImageInfo__S() = default;
        VkDescriptorImageInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDescriptorImageInfo__P: public Encodable {
    public:
        VkDescriptorImageInfo__P() = default;
        VkDescriptorImageInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDescriptorImageInfo__CP: public Encodable {
    public:
        VkDescriptorImageInfo__CP() = default;
        VkDescriptorImageInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDescriptorPoolSize__CP: public Encodable {
    public:
        VkDescriptorPoolSize__CP() = default;
        VkDescriptorPoolSize__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDescriptorPoolCreateInfo: public Encodable {
    public:
        VkDescriptorPoolCreateInfo() = default;
        VkDescriptorPoolCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t MaxSets, uint32_t PoolSizeCount, VkDescriptorPoolSize__CP PPoolSizes)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mMaxSets(MaxSets)
                , mPoolSizeCount(PoolSizeCount)
                , mPPoolSizes(PPoolSizes) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mMaxSets;
        uint32_t mPoolSizeCount;
        VkDescriptorPoolSize__CP mPPoolSizes;
    };

    class VkDescriptorPoolCreateInfo__S: public Encodable {
    public:
        VkDescriptorPoolCreateInfo__S() = default;
        VkDescriptorPoolCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDescriptorPoolCreateInfo__P: public Encodable {
    public:
        VkDescriptorPoolCreateInfo__P() = default;
        VkDescriptorPoolCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDescriptorPoolSize: public Encodable {
    public:
        VkDescriptorPoolSize() = default;
        VkDescriptorPoolSize(uint32_t Type, uint32_t DescriptorCount)
                : mType(Type)
                , mDescriptorCount(DescriptorCount) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mType);
            e->Uint32(this->mDescriptorCount);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mType;
        uint32_t mDescriptorCount;
    };

    class VkDescriptorPoolSize__S: public Encodable {
    public:
        VkDescriptorPoolSize__S() = default;
        VkDescriptorPoolSize__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDescriptorPoolSize__P: public Encodable {
    public:
        VkDescriptorPoolSize__P() = default;
        VkDescriptorPoolSize__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDescriptorPool__S: public Encodable {
    public:
        VkDescriptorPool__S() = default;
        VkDescriptorPool__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDescriptorSetLayout__CP: public Encodable {
    public:
        VkDescriptorSetLayout__CP() = default;
        VkDescriptorSetLayout__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDescriptorSetAllocateInfo: public Encodable {
    public:
        VkDescriptorSetAllocateInfo() = default;
        VkDescriptorSetAllocateInfo(uint32_t SType, Void__CP PNext, uint64_t DescriptorPool, uint32_t DescriptorSetCount, VkDescriptorSetLayout__CP PSetLayouts)
                : mSType(SType)
                , mPNext(PNext)
                , mDescriptorPool(DescriptorPool)
                , mDescriptorSetCount(DescriptorSetCount)
                , mPSetLayouts(PSetLayouts) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint64_t mDescriptorPool;
        uint32_t mDescriptorSetCount;
        VkDescriptorSetLayout__CP mPSetLayouts;
    };

    class VkDescriptorSetAllocateInfo__S: public Encodable {
    public:
        VkDescriptorSetAllocateInfo__S() = default;
        VkDescriptorSetAllocateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDescriptorSetAllocateInfo__P: public Encodable {
    public:
        VkDescriptorSetAllocateInfo__P() = default;
        VkDescriptorSetAllocateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSampler__CP: public Encodable {
    public:
        VkSampler__CP() = default;
        VkSampler__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDescriptorSetLayoutBinding: public Encodable {
    public:
        VkDescriptorSetLayoutBinding() = default;
        VkDescriptorSetLayoutBinding(uint32_t Binding, uint32_t DescriptorType, uint32_t DescriptorCount, uint32_t StageFlags, VkSampler__CP PImmutableSamplers)
                : mBinding(Binding)
                , mDescriptorType(DescriptorType)
                , mDescriptorCount(DescriptorCount)
                , mStageFlags(StageFlags)
                , mPImmutableSamplers(PImmutableSamplers) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mBinding;
        uint32_t mDescriptorType;
        uint32_t mDescriptorCount;
        uint32_t mStageFlags;
        VkSampler__CP mPImmutableSamplers;
    };

    class VkDescriptorSetLayoutBinding__S: public Encodable {
    public:
        VkDescriptorSetLayoutBinding__S() = default;
        VkDescriptorSetLayoutBinding__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDescriptorSetLayoutBinding__P: public Encodable {
    public:
        VkDescriptorSetLayoutBinding__P() = default;
        VkDescriptorSetLayoutBinding__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDescriptorSetLayoutBinding__CP: public Encodable {
    public:
        VkDescriptorSetLayoutBinding__CP() = default;
        VkDescriptorSetLayoutBinding__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDescriptorSetLayoutCreateInfo: public Encodable {
    public:
        VkDescriptorSetLayoutCreateInfo() = default;
        VkDescriptorSetLayoutCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t BindingCount, VkDescriptorSetLayoutBinding__CP PBindings)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mBindingCount(BindingCount)
                , mPBindings(PBindings) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mBindingCount;
        VkDescriptorSetLayoutBinding__CP mPBindings;
    };

    class VkDescriptorSetLayoutCreateInfo__S: public Encodable {
    public:
        VkDescriptorSetLayoutCreateInfo__S() = default;
        VkDescriptorSetLayoutCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDescriptorSetLayoutCreateInfo__P: public Encodable {
    public:
        VkDescriptorSetLayoutCreateInfo__P() = default;
        VkDescriptorSetLayoutCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDescriptorSetLayout__S: public Encodable {
    public:
        VkDescriptorSetLayout__S() = default;
        VkDescriptorSetLayout__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDescriptorSet__S: public Encodable {
    public:
        VkDescriptorSet__S() = default;
        VkDescriptorSet__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDestroyBuffer: public Encodable {
    public:
        VkDestroyBuffer() = default;
        VkDestroyBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Buffer, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mBuffer(Buffer)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mBuffer;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyBufferView: public Encodable {
    public:
        VkDestroyBufferView() = default;
        VkDestroyBufferView(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t BufferView, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mBufferView(BufferView)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mBufferView;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyCommandPool: public Encodable {
    public:
        VkDestroyCommandPool() = default;
        VkDestroyCommandPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t CommandPool, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mCommandPool(CommandPool)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mCommandPool;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyDebugReportCallbackEXT: public Encodable {
    public:
        VkDestroyDebugReportCallbackEXT() = default;
        VkDestroyDebugReportCallbackEXT(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, uint64_t Callback, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mInstance(Instance)
                , mCallback(Callback)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mInstance;
        uint64_t mCallback;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyDescriptorPool: public Encodable {
    public:
        VkDestroyDescriptorPool() = default;
        VkDestroyDescriptorPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t DescriptorPool, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mDescriptorPool(DescriptorPool)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mDescriptorPool;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyDescriptorSetLayout: public Encodable {
    public:
        VkDestroyDescriptorSetLayout() = default;
        VkDestroyDescriptorSetLayout(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t DescriptorSetLayout, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mDescriptorSetLayout(DescriptorSetLayout)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mDescriptorSetLayout;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyDevice: public Encodable {
    public:
        VkDestroyDevice() = default;
        VkDestroyDevice(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mDevice);
            e->Struct(this->mPAllocator);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyEvent: public Encodable {
    public:
        VkDestroyEvent() = default;
        VkDestroyEvent(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Event, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mEvent(Event)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mEvent;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyFence: public Encodable {
    public:
        VkDestroyFence() = default;
        VkDestroyFence(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Fence, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mFence(Fence)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mFence;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyFramebuffer: public Encodable {
    public:
        VkDestroyFramebuffer() = default;
        VkDestroyFramebuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Framebuffer, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mFramebuffer(Framebuffer)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mFramebuffer;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyImage: public Encodable {
    public:
        VkDestroyImage() = default;
        VkDestroyImage(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Image, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mImage(Image)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mImage;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyImageView: public Encodable {
    public:
        VkDestroyImageView() = default;
        VkDestroyImageView(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t ImageView, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mImageView(ImageView)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mImageView;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyInstance: public Encodable {
    public:
        VkDestroyInstance() = default;
        VkDestroyInstance(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mInstance(Instance)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mInstance);
            e->Struct(this->mPAllocator);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mInstance;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyPipeline: public Encodable {
    public:
        VkDestroyPipeline() = default;
        VkDestroyPipeline(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Pipeline, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mPipeline(Pipeline)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mPipeline;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyPipelineCache: public Encodable {
    public:
        VkDestroyPipelineCache() = default;
        VkDestroyPipelineCache(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t PipelineCache, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mPipelineCache(PipelineCache)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mPipelineCache;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyPipelineLayout: public Encodable {
    public:
        VkDestroyPipelineLayout() = default;
        VkDestroyPipelineLayout(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t PipelineLayout, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mPipelineLayout(PipelineLayout)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mPipelineLayout;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyQueryPool: public Encodable {
    public:
        VkDestroyQueryPool() = default;
        VkDestroyQueryPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t QueryPool, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mQueryPool(QueryPool)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mQueryPool;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyRenderPass: public Encodable {
    public:
        VkDestroyRenderPass() = default;
        VkDestroyRenderPass(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t RenderPass, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mRenderPass(RenderPass)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mRenderPass;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroySampler: public Encodable {
    public:
        VkDestroySampler() = default;
        VkDestroySampler(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Sampler, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mSampler(Sampler)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mSampler;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroySemaphore: public Encodable {
    public:
        VkDestroySemaphore() = default;
        VkDestroySemaphore(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Semaphore, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mSemaphore(Semaphore)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mSemaphore;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroyShaderModule: public Encodable {
    public:
        VkDestroyShaderModule() = default;
        VkDestroyShaderModule(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t ShaderModule, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mShaderModule(ShaderModule)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mShaderModule;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroySurfaceKHR: public Encodable {
    public:
        VkDestroySurfaceKHR() = default;
        VkDestroySurfaceKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, uint64_t Surface, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mInstance(Instance)
                , mSurface(Surface)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mInstance;
        uint64_t mSurface;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDestroySwapchainKHR: public Encodable {
    public:
        VkDestroySwapchainKHR() = default;
        VkDestroySwapchainKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Swapchain, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mSwapchain(Swapchain)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mSwapchain;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkDeviceQueueCreateInfo__CP: public Encodable {
    public:
        VkDeviceQueueCreateInfo__CP() = default;
        VkDeviceQueueCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPhysicalDeviceFeatures__CP: public Encodable {
    public:
        VkPhysicalDeviceFeatures__CP() = default;
        VkPhysicalDeviceFeatures__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDeviceCreateInfo: public Encodable {
    public:
        VkDeviceCreateInfo() = default;
        VkDeviceCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t QueueCreateInfoCount, VkDeviceQueueCreateInfo__CP PQueueCreateInfos, uint32_t EnabledLayerCount, Char__CP__CP PpEnabledLayerNames, uint32_t EnabledExtensionCount, Char__CP__CP PpEnabledExtensionNames, VkPhysicalDeviceFeatures__CP PEnabledFeatures)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mQueueCreateInfoCount(QueueCreateInfoCount)
                , mPQueueCreateInfos(PQueueCreateInfos)
                , mEnabledLayerCount(EnabledLayerCount)
                , mPpEnabledLayerNames(PpEnabledLayerNames)
                , mEnabledExtensionCount(EnabledExtensionCount)
                , mPpEnabledExtensionNames(PpEnabledExtensionNames)
                , mPEnabledFeatures(PEnabledFeatures) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mQueueCreateInfoCount;
        VkDeviceQueueCreateInfo__CP mPQueueCreateInfos;
        uint32_t mEnabledLayerCount;
        Char__CP__CP mPpEnabledLayerNames;
        uint32_t mEnabledExtensionCount;
        Char__CP__CP mPpEnabledExtensionNames;
        VkPhysicalDeviceFeatures__CP mPEnabledFeatures;
    };

    class VkDeviceCreateInfo__S: public Encodable {
    public:
        VkDeviceCreateInfo__S() = default;
        VkDeviceCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDeviceMemory__S: public Encodable {
    public:
        VkDeviceMemory__S() = default;
        VkDeviceMemory__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDeviceQueueCreateInfo: public Encodable {
    public:
        VkDeviceQueueCreateInfo() = default;
        VkDeviceQueueCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t QueueFamilyIndex, uint32_t QueueCount, F32__CP PQueuePriorities)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mQueueFamilyIndex(QueueFamilyIndex)
                , mQueueCount(QueueCount)
                , mPQueuePriorities(PQueuePriorities) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mQueueFamilyIndex;
        uint32_t mQueueCount;
        F32__CP mPQueuePriorities;
    };

    class VkDeviceQueueCreateInfo__S: public Encodable {
    public:
        VkDeviceQueueCreateInfo__S() = default;
        VkDeviceQueueCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDeviceQueueCreateInfo__P: public Encodable {
    public:
        VkDeviceQueueCreateInfo__P() = default;
        VkDeviceQueueCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDeviceSize__S: public Encodable {
    public:
        VkDeviceSize__S() = default;
        VkDeviceSize__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDeviceSize__P: public Encodable {
    public:
        VkDeviceSize__P() = default;
        VkDeviceSize__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDeviceWaitIdle: public Encodable {
    public:
        VkDeviceWaitIdle() = default;
        VkDeviceWaitIdle(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mDevice);
            e->Uint32(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint32_t mResult;
    };

    class VkDevice__S: public Encodable {
    public:
        VkDevice__S() = default;
        VkDevice__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDispatchIndirectCommand: public Encodable {
    public:
        VkDispatchIndirectCommand() = default;
        VkDispatchIndirectCommand(uint32_t X, uint32_t Y, uint32_t Z)
                : mX(X)
                , mY(Y)
                , mZ(Z) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mX);
            e->Uint32(this->mY);
            e->Uint32(this->mZ);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mX;
        uint32_t mY;
        uint32_t mZ;
    };

    class VkDisplayKHR__S: public Encodable {
    public:
        VkDisplayKHR__S() = default;
        VkDisplayKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDisplayKHR__P: public Encodable {
    public:
        VkDisplayKHR__P() = default;
        VkDisplayKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDisplayModeParametersKHR: public Encodable {
    public:
        VkDisplayModeParametersKHR() = default;
        VkDisplayModeParametersKHR(VkExtent2D VisibleRegion, uint32_t RefreshRate)
                : mVisibleRegion(VisibleRegion)
                , mRefreshRate(RefreshRate) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mVisibleRegion);
            e->Uint32(this->mRefreshRate);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        VkExtent2D mVisibleRegion;
        uint32_t mRefreshRate;
    };

    class VkDisplayModeCreateInfoKHR: public Encodable {
    public:
        VkDisplayModeCreateInfoKHR() = default;
        VkDisplayModeCreateInfoKHR(uint32_t SType, Void__CP PNext, uint32_t Flags, VkDisplayModeParametersKHR Parameters)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mParameters(Parameters) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        VkDisplayModeParametersKHR mParameters;
    };

    class VkDisplayModeCreateInfoKHR__S: public Encodable {
    public:
        VkDisplayModeCreateInfoKHR__S() = default;
        VkDisplayModeCreateInfoKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDisplayModeCreateInfoKHR__P: public Encodable {
    public:
        VkDisplayModeCreateInfoKHR__P() = default;
        VkDisplayModeCreateInfoKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDisplayModeKHR__S: public Encodable {
    public:
        VkDisplayModeKHR__S() = default;
        VkDisplayModeKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDisplayModePropertiesKHR: public Encodable {
    public:
        VkDisplayModePropertiesKHR() = default;
        VkDisplayModePropertiesKHR(uint64_t DisplayMode, VkDisplayModeParametersKHR Parameters)
                : mDisplayMode(DisplayMode)
                , mParameters(Parameters) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mDisplayMode);
            e->Struct(this->mParameters);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mDisplayMode;
        VkDisplayModeParametersKHR mParameters;
    };

    class VkDisplayModePropertiesKHR__S: public Encodable {
    public:
        VkDisplayModePropertiesKHR__S() = default;
        VkDisplayModePropertiesKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDisplayModePropertiesKHR__P: public Encodable {
    public:
        VkDisplayModePropertiesKHR__P() = default;
        VkDisplayModePropertiesKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDisplayPlaneCapabilitiesKHR: public Encodable {
    public:
        VkDisplayPlaneCapabilitiesKHR() = default;
        VkDisplayPlaneCapabilitiesKHR(uint32_t SupportedAlpha, VkOffset2D MinSrcPosition, VkOffset2D MaxSrcPosition, VkExtent2D MinSrcExtent, VkExtent2D MaxSrcExtent, VkOffset2D MinDstPosition, VkOffset2D MaxDstPosition, VkExtent2D MinDstExtent, VkExtent2D MaxDstExtent)
                : mSupportedAlpha(SupportedAlpha)
                , mMinSrcPosition(MinSrcPosition)
                , mMaxSrcPosition(MaxSrcPosition)
                , mMinSrcExtent(MinSrcExtent)
                , mMaxSrcExtent(MaxSrcExtent)
                , mMinDstPosition(MinDstPosition)
                , mMaxDstPosition(MaxDstPosition)
                , mMinDstExtent(MinDstExtent)
                , mMaxDstExtent(MaxDstExtent) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSupportedAlpha;
        VkOffset2D mMinSrcPosition;
        VkOffset2D mMaxSrcPosition;
        VkExtent2D mMinSrcExtent;
        VkExtent2D mMaxSrcExtent;
        VkOffset2D mMinDstPosition;
        VkOffset2D mMaxDstPosition;
        VkExtent2D mMinDstExtent;
        VkExtent2D mMaxDstExtent;
    };

    class VkDisplayPlaneCapabilitiesKHR__S: public Encodable {
    public:
        VkDisplayPlaneCapabilitiesKHR__S() = default;
        VkDisplayPlaneCapabilitiesKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDisplayPlaneCapabilitiesKHR__P: public Encodable {
    public:
        VkDisplayPlaneCapabilitiesKHR__P() = default;
        VkDisplayPlaneCapabilitiesKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDisplayPlanePropertiesKHR: public Encodable {
    public:
        VkDisplayPlanePropertiesKHR() = default;
        VkDisplayPlanePropertiesKHR(uint64_t CurrentDisplay, uint32_t CurrentStackIndex)
                : mCurrentDisplay(CurrentDisplay)
                , mCurrentStackIndex(CurrentStackIndex) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mCurrentDisplay);
            e->Uint32(this->mCurrentStackIndex);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mCurrentDisplay;
        uint32_t mCurrentStackIndex;
    };

    class VkDisplayPlanePropertiesKHR__S: public Encodable {
    public:
        VkDisplayPlanePropertiesKHR__S() = default;
        VkDisplayPlanePropertiesKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDisplayPlanePropertiesKHR__P: public Encodable {
    public:
        VkDisplayPlanePropertiesKHR__P() = default;
        VkDisplayPlanePropertiesKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDisplayPresentInfoKHR: public Encodable {
    public:
        VkDisplayPresentInfoKHR() = default;
        VkDisplayPresentInfoKHR(uint32_t SType, Void__CP PNext, VkRect2D SrcRect, VkRect2D DstRect, uint32_t Persistent)
                : mSType(SType)
                , mPNext(PNext)
                , mSrcRect(SrcRect)
                , mDstRect(DstRect)
                , mPersistent(Persistent) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        VkRect2D mSrcRect;
        VkRect2D mDstRect;
        uint32_t mPersistent;
    };

    class VkDisplayPropertiesKHR: public Encodable {
    public:
        VkDisplayPropertiesKHR() = default;
        VkDisplayPropertiesKHR(uint64_t Display, const char* DisplayName, VkExtent2D PhysicalDimensions, VkExtent2D PhysicalResolution, uint32_t SupportedTransforms, uint32_t PlaneReorderPossible, uint32_t PersistentContent)
                : mDisplay(Display)
                , mDisplayName(DisplayName)
                , mPhysicalDimensions(PhysicalDimensions)
                , mPhysicalResolution(PhysicalResolution)
                , mSupportedTransforms(SupportedTransforms)
                , mPlaneReorderPossible(PlaneReorderPossible)
                , mPersistentContent(PersistentContent) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mDisplay;
        const char* mDisplayName;
        VkExtent2D mPhysicalDimensions;
        VkExtent2D mPhysicalResolution;
        uint32_t mSupportedTransforms;
        uint32_t mPlaneReorderPossible;
        uint32_t mPersistentContent;
    };

    class VkDisplayPropertiesKHR__S: public Encodable {
    public:
        VkDisplayPropertiesKHR__S() = default;
        VkDisplayPropertiesKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDisplayPropertiesKHR__P: public Encodable {
    public:
        VkDisplayPropertiesKHR__P() = default;
        VkDisplayPropertiesKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDisplaySurfaceCreateInfoKHR: public Encodable {
    public:
        VkDisplaySurfaceCreateInfoKHR() = default;
        VkDisplaySurfaceCreateInfoKHR(uint32_t SType, Void__CP PNext, uint32_t Flags, uint64_t DisplayMode, uint32_t PlaneIndex, uint32_t PlaneStackIndex, uint32_t Transform, float GlobalAlpha, uint32_t AlphaMode, VkExtent2D ImageExtent)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mDisplayMode(DisplayMode)
                , mPlaneIndex(PlaneIndex)
                , mPlaneStackIndex(PlaneStackIndex)
                , mTransform(Transform)
                , mGlobalAlpha(GlobalAlpha)
                , mAlphaMode(AlphaMode)
                , mImageExtent(ImageExtent) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint64_t mDisplayMode;
        uint32_t mPlaneIndex;
        uint32_t mPlaneStackIndex;
        uint32_t mTransform;
        float mGlobalAlpha;
        uint32_t mAlphaMode;
        VkExtent2D mImageExtent;
    };

    class VkDisplaySurfaceCreateInfoKHR__S: public Encodable {
    public:
        VkDisplaySurfaceCreateInfoKHR__S() = default;
        VkDisplaySurfaceCreateInfoKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDisplaySurfaceCreateInfoKHR__P: public Encodable {
    public:
        VkDisplaySurfaceCreateInfoKHR__P() = default;
        VkDisplaySurfaceCreateInfoKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDrawIndexedIndirectCommand: public Encodable {
    public:
        VkDrawIndexedIndirectCommand() = default;
        VkDrawIndexedIndirectCommand(uint32_t IndexCount, uint32_t InstanceCount, uint32_t FirstIndex, int32_t VertexOffset, uint32_t FirstInstance)
                : mIndexCount(IndexCount)
                , mInstanceCount(InstanceCount)
                , mFirstIndex(FirstIndex)
                , mVertexOffset(VertexOffset)
                , mFirstInstance(FirstInstance) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mIndexCount;
        uint32_t mInstanceCount;
        uint32_t mFirstIndex;
        int32_t mVertexOffset;
        uint32_t mFirstInstance;
    };

    class VkDrawIndirectCommand: public Encodable {
    public:
        VkDrawIndirectCommand() = default;
        VkDrawIndirectCommand(uint32_t VertexCount, uint32_t InstanceCount, uint32_t FirstVertex, uint32_t FirstInstance)
                : mVertexCount(VertexCount)
                , mInstanceCount(InstanceCount)
                , mFirstVertex(FirstVertex)
                , mFirstInstance(FirstInstance) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mVertexCount;
        uint32_t mInstanceCount;
        uint32_t mFirstVertex;
        uint32_t mFirstInstance;
    };

    class VkDynamicState__S: public Encodable {
    public:
        VkDynamicState__S() = default;
        VkDynamicState__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkDynamicState__P: public Encodable {
    public:
        VkDynamicState__P() = default;
        VkDynamicState__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkDynamicState__CP: public Encodable {
    public:
        VkDynamicState__CP() = default;
        VkDynamicState__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkEndCommandBuffer: public Encodable {
    public:
        VkEndCommandBuffer() = default;
        VkEndCommandBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t Result)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mCommandBuffer);
            e->Uint32(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mResult;
    };

    class VkExtensionProperties__P: public Encodable {
    public:
        VkExtensionProperties__P() = default;
        VkExtensionProperties__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkEnumerateDeviceExtensionProperties: public Encodable {
    public:
        VkEnumerateDeviceExtensionProperties() = default;
        VkEnumerateDeviceExtensionProperties(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, const char* PLayerName, U32__P PPropertyCount, VkExtensionProperties__P PProperties, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mPLayerName(PLayerName)
                , mPPropertyCount(PPropertyCount)
                , mPProperties(PProperties)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        const char* mPLayerName;
        U32__P mPPropertyCount;
        VkExtensionProperties__P mPProperties;
        uint32_t mResult;
    };

    class VkLayerProperties__P: public Encodable {
    public:
        VkLayerProperties__P() = default;
        VkLayerProperties__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkEnumerateDeviceLayerProperties: public Encodable {
    public:
        VkEnumerateDeviceLayerProperties() = default;
        VkEnumerateDeviceLayerProperties(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, U32__P PPropertyCount, VkLayerProperties__P PProperties, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mPPropertyCount(PPropertyCount)
                , mPProperties(PProperties)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        U32__P mPPropertyCount;
        VkLayerProperties__P mPProperties;
        uint32_t mResult;
    };

    class VkEnumerateInstanceExtensionProperties: public Encodable {
    public:
        VkEnumerateInstanceExtensionProperties() = default;
        VkEnumerateInstanceExtensionProperties(const gapic::Vector<gapic::Encodable*>& extras, const char* PLayerName, U32__P PPropertyCount, VkExtensionProperties__P PProperties, uint32_t Result)
                : mextras(extras)
                , mPLayerName(PLayerName)
                , mPPropertyCount(PPropertyCount)
                , mPProperties(PProperties)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        const char* mPLayerName;
        U32__P mPPropertyCount;
        VkExtensionProperties__P mPProperties;
        uint32_t mResult;
    };

    class VkEnumerateInstanceLayerProperties: public Encodable {
    public:
        VkEnumerateInstanceLayerProperties() = default;
        VkEnumerateInstanceLayerProperties(const gapic::Vector<gapic::Encodable*>& extras, U32__P PPropertyCount, VkLayerProperties__P PProperties, uint32_t Result)
                : mextras(extras)
                , mPPropertyCount(PPropertyCount)
                , mPProperties(PProperties)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        U32__P mPPropertyCount;
        VkLayerProperties__P mPProperties;
        uint32_t mResult;
    };

    class VkPhysicalDevice__P: public Encodable {
    public:
        VkPhysicalDevice__P() = default;
        VkPhysicalDevice__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkEnumeratePhysicalDevices: public Encodable {
    public:
        VkEnumeratePhysicalDevices() = default;
        VkEnumeratePhysicalDevices(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, U32__P PPhysicalDeviceCount, VkPhysicalDevice__P PPhysicalDevices, uint32_t Result)
                : mextras(extras)
                , mInstance(Instance)
                , mPPhysicalDeviceCount(PPhysicalDeviceCount)
                , mPPhysicalDevices(PPhysicalDevices)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mInstance;
        U32__P mPPhysicalDeviceCount;
        VkPhysicalDevice__P mPPhysicalDevices;
        uint32_t mResult;
    };

    class VkEventCreateInfo: public Encodable {
    public:
        VkEventCreateInfo() = default;
        VkEventCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mSType);
            e->Struct(this->mPNext);
            e->Uint32(this->mFlags);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
    };

    class VkEventCreateInfo__S: public Encodable {
    public:
        VkEventCreateInfo__S() = default;
        VkEventCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkEventCreateInfo__P: public Encodable {
    public:
        VkEventCreateInfo__P() = default;
        VkEventCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkEvent__S: public Encodable {
    public:
        VkEvent__S() = default;
        VkEvent__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkExtensionProperties: public Encodable {
    public:
        VkExtensionProperties() = default;
        VkExtensionProperties(Char__256__A ExtensionName, uint32_t SpecVersion)
                : mExtensionName(ExtensionName)
                , mSpecVersion(SpecVersion) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mExtensionName);
            e->Uint32(this->mSpecVersion);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        Char__256__A mExtensionName;
        uint32_t mSpecVersion;
    };

    class VkExtensionProperties__S: public Encodable {
    public:
        VkExtensionProperties__S() = default;
        VkExtensionProperties__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkExtent2D__S: public Encodable {
    public:
        VkExtent2D__S() = default;
        VkExtent2D__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkExtent2D__P: public Encodable {
    public:
        VkExtent2D__P() = default;
        VkExtent2D__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkFenceCreateInfo: public Encodable {
    public:
        VkFenceCreateInfo() = default;
        VkFenceCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mSType);
            e->Struct(this->mPNext);
            e->Uint32(this->mFlags);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
    };

    class VkFenceCreateInfo__S: public Encodable {
    public:
        VkFenceCreateInfo__S() = default;
        VkFenceCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkFenceCreateInfo__P: public Encodable {
    public:
        VkFenceCreateInfo__P() = default;
        VkFenceCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkFence__S: public Encodable {
    public:
        VkFence__S() = default;
        VkFence__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkFence__CP: public Encodable {
    public:
        VkFence__CP() = default;
        VkFence__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkMappedMemoryRange__CP: public Encodable {
    public:
        VkMappedMemoryRange__CP() = default;
        VkMappedMemoryRange__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkFlushMappedMemoryRanges: public Encodable {
    public:
        VkFlushMappedMemoryRanges() = default;
        VkFlushMappedMemoryRanges(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t MemoryRangeCount, VkMappedMemoryRange__CP PMemoryRanges, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mMemoryRangeCount(MemoryRangeCount)
                , mPMemoryRanges(PMemoryRanges)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint32_t mMemoryRangeCount;
        VkMappedMemoryRange__CP mPMemoryRanges;
        uint32_t mResult;
    };

    class VkFormatProperties: public Encodable {
    public:
        VkFormatProperties() = default;
        VkFormatProperties(uint32_t LinearTilingFeatures, uint32_t OptimalTilingFeatures, uint32_t BufferFeatures)
                : mLinearTilingFeatures(LinearTilingFeatures)
                , mOptimalTilingFeatures(OptimalTilingFeatures)
                , mBufferFeatures(BufferFeatures) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mLinearTilingFeatures);
            e->Uint32(this->mOptimalTilingFeatures);
            e->Uint32(this->mBufferFeatures);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mLinearTilingFeatures;
        uint32_t mOptimalTilingFeatures;
        uint32_t mBufferFeatures;
    };

    class VkFormatProperties__S: public Encodable {
    public:
        VkFormatProperties__S() = default;
        VkFormatProperties__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkFormatProperties__P: public Encodable {
    public:
        VkFormatProperties__P() = default;
        VkFormatProperties__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkImageView__CP: public Encodable {
    public:
        VkImageView__CP() = default;
        VkImageView__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkFramebufferCreateInfo: public Encodable {
    public:
        VkFramebufferCreateInfo() = default;
        VkFramebufferCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint64_t RenderPass, uint32_t AttachmentCount, VkImageView__CP PAttachments, uint32_t Width, uint32_t Height, uint32_t Layers)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mRenderPass(RenderPass)
                , mAttachmentCount(AttachmentCount)
                , mPAttachments(PAttachments)
                , mWidth(Width)
                , mHeight(Height)
                , mLayers(Layers) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint64_t mRenderPass;
        uint32_t mAttachmentCount;
        VkImageView__CP mPAttachments;
        uint32_t mWidth;
        uint32_t mHeight;
        uint32_t mLayers;
    };

    class VkFramebufferCreateInfo__S: public Encodable {
    public:
        VkFramebufferCreateInfo__S() = default;
        VkFramebufferCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkFramebufferCreateInfo__P: public Encodable {
    public:
        VkFramebufferCreateInfo__P() = default;
        VkFramebufferCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkFramebuffer__S: public Encodable {
    public:
        VkFramebuffer__S() = default;
        VkFramebuffer__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkFreeCommandBuffers: public Encodable {
    public:
        VkFreeCommandBuffers() = default;
        VkFreeCommandBuffers(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t CommandPool, uint32_t CommandBufferCount, VkCommandBuffer__CP PCommandBuffers)
                : mextras(extras)
                , mDevice(Device)
                , mCommandPool(CommandPool)
                , mCommandBufferCount(CommandBufferCount)
                , mPCommandBuffers(PCommandBuffers) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mCommandPool;
        uint32_t mCommandBufferCount;
        VkCommandBuffer__CP mPCommandBuffers;
    };

    class VkFreeDescriptorSets: public Encodable {
    public:
        VkFreeDescriptorSets() = default;
        VkFreeDescriptorSets(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t DescriptorPool, uint32_t DescriptorSetCount, VkDescriptorSet__CP PDescriptorSets, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mDescriptorPool(DescriptorPool)
                , mDescriptorSetCount(DescriptorSetCount)
                , mPDescriptorSets(PDescriptorSets)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mDescriptorPool;
        uint32_t mDescriptorSetCount;
        VkDescriptorSet__CP mPDescriptorSets;
        uint32_t mResult;
    };

    class VkFreeMemory: public Encodable {
    public:
        VkFreeMemory() = default;
        VkFreeMemory(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Memory, VkAllocationCallbacks__CP PAllocator)
                : mextras(extras)
                , mDevice(Device)
                , mMemory(Memory)
                , mPAllocator(PAllocator) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mMemory;
        VkAllocationCallbacks__CP mPAllocator;
    };

    class VkMemoryRequirements__P: public Encodable {
    public:
        VkMemoryRequirements__P() = default;
        VkMemoryRequirements__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkGetBufferMemoryRequirements: public Encodable {
    public:
        VkGetBufferMemoryRequirements() = default;
        VkGetBufferMemoryRequirements(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Buffer, VkMemoryRequirements__P PMemoryRequirements)
                : mextras(extras)
                , mDevice(Device)
                , mBuffer(Buffer)
                , mPMemoryRequirements(PMemoryRequirements) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mBuffer;
        VkMemoryRequirements__P mPMemoryRequirements;
    };

    class VkGetDeviceMemoryCommitment: public Encodable {
    public:
        VkGetDeviceMemoryCommitment() = default;
        VkGetDeviceMemoryCommitment(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Memory, VkDeviceSize__P PCommittedMemoryInBytes)
                : mextras(extras)
                , mDevice(Device)
                , mMemory(Memory)
                , mPCommittedMemoryInBytes(PCommittedMemoryInBytes) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mMemory;
        VkDeviceSize__P mPCommittedMemoryInBytes;
    };

    class VkGetDeviceProcAddr: public Encodable {
    public:
        VkGetDeviceProcAddr() = default;
        VkGetDeviceProcAddr(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, const char* PName, PFN_vkVoidFunction Result)
                : mextras(extras)
                , mDevice(Device)
                , mPName(PName)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        const char* mPName;
        PFN_vkVoidFunction mResult;
    };

    class VkQueue__P: public Encodable {
    public:
        VkQueue__P() = default;
        VkQueue__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkGetDeviceQueue: public Encodable {
    public:
        VkGetDeviceQueue() = default;
        VkGetDeviceQueue(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t QueueFamilyIndex, uint32_t QueueIndex, VkQueue__P PQueue)
                : mextras(extras)
                , mDevice(Device)
                , mQueueFamilyIndex(QueueFamilyIndex)
                , mQueueIndex(QueueIndex)
                , mPQueue(PQueue) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint32_t mQueueFamilyIndex;
        uint32_t mQueueIndex;
        VkQueue__P mPQueue;
    };

    class VkGetDisplayModePropertiesKHR: public Encodable {
    public:
        VkGetDisplayModePropertiesKHR() = default;
        VkGetDisplayModePropertiesKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint64_t Display, U32__P PPropertyCount, VkDisplayModePropertiesKHR__P PProperties, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mDisplay(Display)
                , mPPropertyCount(PPropertyCount)
                , mPProperties(PProperties)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        uint64_t mDisplay;
        U32__P mPPropertyCount;
        VkDisplayModePropertiesKHR__P mPProperties;
        uint32_t mResult;
    };

    class VkGetDisplayPlaneCapabilitiesKHR: public Encodable {
    public:
        VkGetDisplayPlaneCapabilitiesKHR() = default;
        VkGetDisplayPlaneCapabilitiesKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint64_t Mode, uint32_t PlaneIndex, VkDisplayPlaneCapabilitiesKHR__P PCapabilities, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mMode(Mode)
                , mPlaneIndex(PlaneIndex)
                , mPCapabilities(PCapabilities)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        uint64_t mMode;
        uint32_t mPlaneIndex;
        VkDisplayPlaneCapabilitiesKHR__P mPCapabilities;
        uint32_t mResult;
    };

    class VkGetDisplayPlaneSupportedDisplaysKHR: public Encodable {
    public:
        VkGetDisplayPlaneSupportedDisplaysKHR() = default;
        VkGetDisplayPlaneSupportedDisplaysKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t PlaneIndex, U32__P PDisplayCount, VkDisplayKHR__P PDisplays, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mPlaneIndex(PlaneIndex)
                , mPDisplayCount(PDisplayCount)
                , mPDisplays(PDisplays)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        uint32_t mPlaneIndex;
        U32__P mPDisplayCount;
        VkDisplayKHR__P mPDisplays;
        uint32_t mResult;
    };

    class VkGetEventStatus: public Encodable {
    public:
        VkGetEventStatus() = default;
        VkGetEventStatus(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Event, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mEvent(Event)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mEvent;
        uint32_t mResult;
    };

    class VkGetFenceStatus: public Encodable {
    public:
        VkGetFenceStatus() = default;
        VkGetFenceStatus(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Fence, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mFence(Fence)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mFence;
        uint32_t mResult;
    };

    class VkGetImageMemoryRequirements: public Encodable {
    public:
        VkGetImageMemoryRequirements() = default;
        VkGetImageMemoryRequirements(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Image, VkMemoryRequirements__P PMemoryRequirements)
                : mextras(extras)
                , mDevice(Device)
                , mImage(Image)
                , mPMemoryRequirements(PMemoryRequirements) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mImage;
        VkMemoryRequirements__P mPMemoryRequirements;
    };

    class VkSparseImageMemoryRequirements__P: public Encodable {
    public:
        VkSparseImageMemoryRequirements__P() = default;
        VkSparseImageMemoryRequirements__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkGetImageSparseMemoryRequirements: public Encodable {
    public:
        VkGetImageSparseMemoryRequirements() = default;
        VkGetImageSparseMemoryRequirements(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Image, U32__P PSparseMemoryRequirementCount, VkSparseImageMemoryRequirements__P PSparseMemoryRequirements)
                : mextras(extras)
                , mDevice(Device)
                , mImage(Image)
                , mPSparseMemoryRequirementCount(PSparseMemoryRequirementCount)
                , mPSparseMemoryRequirements(PSparseMemoryRequirements) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mImage;
        U32__P mPSparseMemoryRequirementCount;
        VkSparseImageMemoryRequirements__P mPSparseMemoryRequirements;
    };

    class VkImageSubresource__CP: public Encodable {
    public:
        VkImageSubresource__CP() = default;
        VkImageSubresource__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSubresourceLayout__P: public Encodable {
    public:
        VkSubresourceLayout__P() = default;
        VkSubresourceLayout__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkGetImageSubresourceLayout: public Encodable {
    public:
        VkGetImageSubresourceLayout() = default;
        VkGetImageSubresourceLayout(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Image, VkImageSubresource__CP PSubresource, VkSubresourceLayout__P PLayout)
                : mextras(extras)
                , mDevice(Device)
                , mImage(Image)
                , mPSubresource(PSubresource)
                , mPLayout(PLayout) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mImage;
        VkImageSubresource__CP mPSubresource;
        VkSubresourceLayout__P mPLayout;
    };

    class VkGetInstanceProcAddr: public Encodable {
    public:
        VkGetInstanceProcAddr() = default;
        VkGetInstanceProcAddr(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, const char* PName, PFN_vkVoidFunction Result)
                : mextras(extras)
                , mInstance(Instance)
                , mPName(PName)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mInstance;
        const char* mPName;
        PFN_vkVoidFunction mResult;
    };

    class VkGetPhysicalDeviceDisplayPlanePropertiesKHR: public Encodable {
    public:
        VkGetPhysicalDeviceDisplayPlanePropertiesKHR() = default;
        VkGetPhysicalDeviceDisplayPlanePropertiesKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, U32__P PPropertyCount, VkDisplayPlanePropertiesKHR__P PProperties, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mPPropertyCount(PPropertyCount)
                , mPProperties(PProperties)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        U32__P mPPropertyCount;
        VkDisplayPlanePropertiesKHR__P mPProperties;
        uint32_t mResult;
    };

    class VkGetPhysicalDeviceDisplayPropertiesKHR: public Encodable {
    public:
        VkGetPhysicalDeviceDisplayPropertiesKHR() = default;
        VkGetPhysicalDeviceDisplayPropertiesKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, U32__P PPropertyCount, VkDisplayPropertiesKHR__P PProperties, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mPPropertyCount(PPropertyCount)
                , mPProperties(PProperties)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        U32__P mPPropertyCount;
        VkDisplayPropertiesKHR__P mPProperties;
        uint32_t mResult;
    };

    class VkPhysicalDeviceFeatures__P: public Encodable {
    public:
        VkPhysicalDeviceFeatures__P() = default;
        VkPhysicalDeviceFeatures__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkGetPhysicalDeviceFeatures: public Encodable {
    public:
        VkGetPhysicalDeviceFeatures() = default;
        VkGetPhysicalDeviceFeatures(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, VkPhysicalDeviceFeatures__P PFeatures)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mPFeatures(PFeatures) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mPhysicalDevice);
            e->Struct(this->mPFeatures);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        VkPhysicalDeviceFeatures__P mPFeatures;
    };

    class VkGetPhysicalDeviceFormatProperties: public Encodable {
    public:
        VkGetPhysicalDeviceFormatProperties() = default;
        VkGetPhysicalDeviceFormatProperties(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t Format, VkFormatProperties__P PFormatProperties)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mFormat(Format)
                , mPFormatProperties(PFormatProperties) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        uint32_t mFormat;
        VkFormatProperties__P mPFormatProperties;
    };

    class VkImageFormatProperties__P: public Encodable {
    public:
        VkImageFormatProperties__P() = default;
        VkImageFormatProperties__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkGetPhysicalDeviceImageFormatProperties: public Encodable {
    public:
        VkGetPhysicalDeviceImageFormatProperties() = default;
        VkGetPhysicalDeviceImageFormatProperties(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t Format, uint32_t Type, uint32_t Tiling, uint32_t Usage, uint32_t Flags, VkImageFormatProperties__P PImageFormatProperties, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mFormat(Format)
                , mType(Type)
                , mTiling(Tiling)
                , mUsage(Usage)
                , mFlags(Flags)
                , mPImageFormatProperties(PImageFormatProperties)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        uint32_t mFormat;
        uint32_t mType;
        uint32_t mTiling;
        uint32_t mUsage;
        uint32_t mFlags;
        VkImageFormatProperties__P mPImageFormatProperties;
        uint32_t mResult;
    };

    class VkPhysicalDeviceMemoryProperties__P: public Encodable {
    public:
        VkPhysicalDeviceMemoryProperties__P() = default;
        VkPhysicalDeviceMemoryProperties__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkGetPhysicalDeviceMemoryProperties: public Encodable {
    public:
        VkGetPhysicalDeviceMemoryProperties() = default;
        VkGetPhysicalDeviceMemoryProperties(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, VkPhysicalDeviceMemoryProperties__P PMemoryProperties)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mPMemoryProperties(PMemoryProperties) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mPhysicalDevice);
            e->Struct(this->mPMemoryProperties);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        VkPhysicalDeviceMemoryProperties__P mPMemoryProperties;
    };

    class VkGetPhysicalDeviceMirPresentationSupportKHR: public Encodable {
    public:
        VkGetPhysicalDeviceMirPresentationSupportKHR() = default;
        VkGetPhysicalDeviceMirPresentationSupportKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t QueueFamilyIndex, MirConnection__P Connection, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mQueueFamilyIndex(QueueFamilyIndex)
                , mConnection(Connection)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        uint32_t mQueueFamilyIndex;
        MirConnection__P mConnection;
        uint32_t mResult;
    };

    class VkPhysicalDeviceProperties__P: public Encodable {
    public:
        VkPhysicalDeviceProperties__P() = default;
        VkPhysicalDeviceProperties__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkGetPhysicalDeviceProperties: public Encodable {
    public:
        VkGetPhysicalDeviceProperties() = default;
        VkGetPhysicalDeviceProperties(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, VkPhysicalDeviceProperties__P PProperties)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mPProperties(PProperties) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mPhysicalDevice);
            e->Struct(this->mPProperties);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        VkPhysicalDeviceProperties__P mPProperties;
    };

    class VkQueueFamilyProperties__P: public Encodable {
    public:
        VkQueueFamilyProperties__P() = default;
        VkQueueFamilyProperties__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkGetPhysicalDeviceQueueFamilyProperties: public Encodable {
    public:
        VkGetPhysicalDeviceQueueFamilyProperties() = default;
        VkGetPhysicalDeviceQueueFamilyProperties(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, U32__P PQueueFamilyPropertyCount, VkQueueFamilyProperties__P PQueueFamilyProperties)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mPQueueFamilyPropertyCount(PQueueFamilyPropertyCount)
                , mPQueueFamilyProperties(PQueueFamilyProperties) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        U32__P mPQueueFamilyPropertyCount;
        VkQueueFamilyProperties__P mPQueueFamilyProperties;
    };

    class VkSparseImageFormatProperties__P: public Encodable {
    public:
        VkSparseImageFormatProperties__P() = default;
        VkSparseImageFormatProperties__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkGetPhysicalDeviceSparseImageFormatProperties: public Encodable {
    public:
        VkGetPhysicalDeviceSparseImageFormatProperties() = default;
        VkGetPhysicalDeviceSparseImageFormatProperties(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t Format, uint32_t Type, uint32_t Samples, uint32_t Usage, uint32_t Tiling, U32__P PPropertyCount, VkSparseImageFormatProperties__P PProperties)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mFormat(Format)
                , mType(Type)
                , mSamples(Samples)
                , mUsage(Usage)
                , mTiling(Tiling)
                , mPPropertyCount(PPropertyCount)
                , mPProperties(PProperties) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        uint32_t mFormat;
        uint32_t mType;
        uint32_t mSamples;
        uint32_t mUsage;
        uint32_t mTiling;
        U32__P mPPropertyCount;
        VkSparseImageFormatProperties__P mPProperties;
    };

    class VkSurfaceCapabilitiesKHR__P: public Encodable {
    public:
        VkSurfaceCapabilitiesKHR__P() = default;
        VkSurfaceCapabilitiesKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkGetPhysicalDeviceSurfaceCapabilitiesKHR: public Encodable {
    public:
        VkGetPhysicalDeviceSurfaceCapabilitiesKHR() = default;
        VkGetPhysicalDeviceSurfaceCapabilitiesKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint64_t Surface, VkSurfaceCapabilitiesKHR__P PSurfaceCapabilities, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mSurface(Surface)
                , mPSurfaceCapabilities(PSurfaceCapabilities)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        uint64_t mSurface;
        VkSurfaceCapabilitiesKHR__P mPSurfaceCapabilities;
        uint32_t mResult;
    };

    class VkSurfaceFormatKHR__P: public Encodable {
    public:
        VkSurfaceFormatKHR__P() = default;
        VkSurfaceFormatKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkGetPhysicalDeviceSurfaceFormatsKHR: public Encodable {
    public:
        VkGetPhysicalDeviceSurfaceFormatsKHR() = default;
        VkGetPhysicalDeviceSurfaceFormatsKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint64_t Surface, U32__P PSurfaceFormatCount, VkSurfaceFormatKHR__P PSurfaceFormats, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mSurface(Surface)
                , mPSurfaceFormatCount(PSurfaceFormatCount)
                , mPSurfaceFormats(PSurfaceFormats)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        uint64_t mSurface;
        U32__P mPSurfaceFormatCount;
        VkSurfaceFormatKHR__P mPSurfaceFormats;
        uint32_t mResult;
    };

    class VkPresentModeKHR__P: public Encodable {
    public:
        VkPresentModeKHR__P() = default;
        VkPresentModeKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkGetPhysicalDeviceSurfacePresentModesKHR: public Encodable {
    public:
        VkGetPhysicalDeviceSurfacePresentModesKHR() = default;
        VkGetPhysicalDeviceSurfacePresentModesKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint64_t Surface, U32__P PPresentModeCount, VkPresentModeKHR__P PPresentModes, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mSurface(Surface)
                , mPPresentModeCount(PPresentModeCount)
                , mPPresentModes(PPresentModes)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        uint64_t mSurface;
        U32__P mPPresentModeCount;
        VkPresentModeKHR__P mPPresentModes;
        uint32_t mResult;
    };

    class VkGetPhysicalDeviceSurfaceSupportKHR: public Encodable {
    public:
        VkGetPhysicalDeviceSurfaceSupportKHR() = default;
        VkGetPhysicalDeviceSurfaceSupportKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t QueueFamilyIndex, uint64_t Surface, VkBool32__P PSupported, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mQueueFamilyIndex(QueueFamilyIndex)
                , mSurface(Surface)
                , mPSupported(PSupported)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        uint32_t mQueueFamilyIndex;
        uint64_t mSurface;
        VkBool32__P mPSupported;
        uint32_t mResult;
    };

    class Wl_display__P: public Encodable {
    public:
        Wl_display__P() = default;
        Wl_display__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkGetPhysicalDeviceWaylandPresentationSupportKHR: public Encodable {
    public:
        VkGetPhysicalDeviceWaylandPresentationSupportKHR() = default;
        VkGetPhysicalDeviceWaylandPresentationSupportKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t QueueFamilyIndex, Wl_display__P Display, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mQueueFamilyIndex(QueueFamilyIndex)
                , mDisplay(Display)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        uint32_t mQueueFamilyIndex;
        Wl_display__P mDisplay;
        uint32_t mResult;
    };

    class Xcb_connection_t__P: public Encodable {
    public:
        Xcb_connection_t__P() = default;
        Xcb_connection_t__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkGetPhysicalDeviceXcbPresentationSupportKHR: public Encodable {
    public:
        VkGetPhysicalDeviceXcbPresentationSupportKHR() = default;
        VkGetPhysicalDeviceXcbPresentationSupportKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t QueueFamilyIndex, Xcb_connection_t__P Connection, uint32_t VisualId, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mQueueFamilyIndex(QueueFamilyIndex)
                , mConnection(Connection)
                , mVisualId(VisualId)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        uint32_t mQueueFamilyIndex;
        Xcb_connection_t__P mConnection;
        uint32_t mVisualId;
        uint32_t mResult;
    };

    class VkGetPhysicalDeviceXlibPresentationSupportKHR: public Encodable {
    public:
        VkGetPhysicalDeviceXlibPresentationSupportKHR() = default;
        VkGetPhysicalDeviceXlibPresentationSupportKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t QueueFamilyIndex, Display__P Dpy, uint64_t VisualID, uint32_t Result)
                : mextras(extras)
                , mPhysicalDevice(PhysicalDevice)
                , mQueueFamilyIndex(QueueFamilyIndex)
                , mDpy(Dpy)
                , mVisualID(VisualID)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mPhysicalDevice;
        uint32_t mQueueFamilyIndex;
        Display__P mDpy;
        uint64_t mVisualID;
        uint32_t mResult;
    };

    class VkGetPipelineCacheData: public Encodable {
    public:
        VkGetPipelineCacheData() = default;
        VkGetPipelineCacheData(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t PipelineCache, Size__P PDataSize, Void__P PData, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mPipelineCache(PipelineCache)
                , mPDataSize(PDataSize)
                , mPData(PData)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mPipelineCache;
        Size__P mPDataSize;
        Void__P mPData;
        uint32_t mResult;
    };

    class VkGetQueryPoolResults: public Encodable {
    public:
        VkGetQueryPoolResults() = default;
        VkGetQueryPoolResults(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t QueryPool, uint32_t FirstQuery, uint32_t QueryCount, uint64_t DataSize, Void__P PData, uint64_t Stride, uint32_t Flags, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mQueryPool(QueryPool)
                , mFirstQuery(FirstQuery)
                , mQueryCount(QueryCount)
                , mDataSize(DataSize)
                , mPData(PData)
                , mStride(Stride)
                , mFlags(Flags)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mQueryPool;
        uint32_t mFirstQuery;
        uint32_t mQueryCount;
        uint64_t mDataSize;
        Void__P mPData;
        uint64_t mStride;
        uint32_t mFlags;
        uint32_t mResult;
    };

    class VkGetRenderAreaGranularity: public Encodable {
    public:
        VkGetRenderAreaGranularity() = default;
        VkGetRenderAreaGranularity(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t RenderPass, VkExtent2D__P PGranularity)
                : mextras(extras)
                , mDevice(Device)
                , mRenderPass(RenderPass)
                , mPGranularity(PGranularity) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mRenderPass;
        VkExtent2D__P mPGranularity;
    };

    class VkGetSwapchainGrallocUsageANDROID: public Encodable {
    public:
        VkGetSwapchainGrallocUsageANDROID() = default;
        VkGetSwapchainGrallocUsageANDROID(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t Format, uint32_t ImageUsage, Int__P GrallocUsage, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mFormat(Format)
                , mImageUsage(ImageUsage)
                , mGrallocUsage(GrallocUsage)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint32_t mFormat;
        uint32_t mImageUsage;
        Int__P mGrallocUsage;
        uint32_t mResult;
    };

    class VkGetSwapchainImagesKHR: public Encodable {
    public:
        VkGetSwapchainImagesKHR() = default;
        VkGetSwapchainImagesKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Swapchain, U32__P PSwapchainImageCount, VkImage__P PSwapchainImages, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mSwapchain(Swapchain)
                , mPSwapchainImageCount(PSwapchainImageCount)
                , mPSwapchainImages(PSwapchainImages)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mSwapchain;
        U32__P mPSwapchainImageCount;
        VkImage__P mPSwapchainImages;
        uint32_t mResult;
    };

    class VkPipelineShaderStageCreateInfo__CP: public Encodable {
    public:
        VkPipelineShaderStageCreateInfo__CP() = default;
        VkPipelineShaderStageCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineVertexInputStateCreateInfo__CP: public Encodable {
    public:
        VkPipelineVertexInputStateCreateInfo__CP() = default;
        VkPipelineVertexInputStateCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineInputAssemblyStateCreateInfo__CP: public Encodable {
    public:
        VkPipelineInputAssemblyStateCreateInfo__CP() = default;
        VkPipelineInputAssemblyStateCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineTessellationStateCreateInfo__CP: public Encodable {
    public:
        VkPipelineTessellationStateCreateInfo__CP() = default;
        VkPipelineTessellationStateCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineViewportStateCreateInfo__CP: public Encodable {
    public:
        VkPipelineViewportStateCreateInfo__CP() = default;
        VkPipelineViewportStateCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineRasterizationStateCreateInfo__CP: public Encodable {
    public:
        VkPipelineRasterizationStateCreateInfo__CP() = default;
        VkPipelineRasterizationStateCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineMultisampleStateCreateInfo__CP: public Encodable {
    public:
        VkPipelineMultisampleStateCreateInfo__CP() = default;
        VkPipelineMultisampleStateCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineDepthStencilStateCreateInfo__CP: public Encodable {
    public:
        VkPipelineDepthStencilStateCreateInfo__CP() = default;
        VkPipelineDepthStencilStateCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineColorBlendStateCreateInfo__CP: public Encodable {
    public:
        VkPipelineColorBlendStateCreateInfo__CP() = default;
        VkPipelineColorBlendStateCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineDynamicStateCreateInfo__CP: public Encodable {
    public:
        VkPipelineDynamicStateCreateInfo__CP() = default;
        VkPipelineDynamicStateCreateInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkGraphicsPipelineCreateInfo: public Encodable {
    public:
        VkGraphicsPipelineCreateInfo() = default;
        VkGraphicsPipelineCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t StageCount, VkPipelineShaderStageCreateInfo__CP PStages, VkPipelineVertexInputStateCreateInfo__CP PVertexInputState, VkPipelineInputAssemblyStateCreateInfo__CP PInputAssemblyState, VkPipelineTessellationStateCreateInfo__CP PTessellationState, VkPipelineViewportStateCreateInfo__CP PViewportState, VkPipelineRasterizationStateCreateInfo__CP PRasterizationState, VkPipelineMultisampleStateCreateInfo__CP PMultisampleState, VkPipelineDepthStencilStateCreateInfo__CP PDepthStencilState, VkPipelineColorBlendStateCreateInfo__CP PColorBlendState, VkPipelineDynamicStateCreateInfo__CP PDynamicState, uint64_t Layout, uint64_t RenderPass, uint32_t Subpass, uint64_t BasePipelineHandle, int32_t BasePipelineIndex)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mStageCount(StageCount)
                , mPStages(PStages)
                , mPVertexInputState(PVertexInputState)
                , mPInputAssemblyState(PInputAssemblyState)
                , mPTessellationState(PTessellationState)
                , mPViewportState(PViewportState)
                , mPRasterizationState(PRasterizationState)
                , mPMultisampleState(PMultisampleState)
                , mPDepthStencilState(PDepthStencilState)
                , mPColorBlendState(PColorBlendState)
                , mPDynamicState(PDynamicState)
                , mLayout(Layout)
                , mRenderPass(RenderPass)
                , mSubpass(Subpass)
                , mBasePipelineHandle(BasePipelineHandle)
                , mBasePipelineIndex(BasePipelineIndex) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mStageCount;
        VkPipelineShaderStageCreateInfo__CP mPStages;
        VkPipelineVertexInputStateCreateInfo__CP mPVertexInputState;
        VkPipelineInputAssemblyStateCreateInfo__CP mPInputAssemblyState;
        VkPipelineTessellationStateCreateInfo__CP mPTessellationState;
        VkPipelineViewportStateCreateInfo__CP mPViewportState;
        VkPipelineRasterizationStateCreateInfo__CP mPRasterizationState;
        VkPipelineMultisampleStateCreateInfo__CP mPMultisampleState;
        VkPipelineDepthStencilStateCreateInfo__CP mPDepthStencilState;
        VkPipelineColorBlendStateCreateInfo__CP mPColorBlendState;
        VkPipelineDynamicStateCreateInfo__CP mPDynamicState;
        uint64_t mLayout;
        uint64_t mRenderPass;
        uint32_t mSubpass;
        uint64_t mBasePipelineHandle;
        int32_t mBasePipelineIndex;
    };

    class VkGraphicsPipelineCreateInfo__S: public Encodable {
    public:
        VkGraphicsPipelineCreateInfo__S() = default;
        VkGraphicsPipelineCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkGraphicsPipelineCreateInfo__P: public Encodable {
    public:
        VkGraphicsPipelineCreateInfo__P() = default;
        VkGraphicsPipelineCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkOffset3D__2__A: public Encodable {
    public:
        VkOffset3D__2__A() = default;
        VkOffset3D__2__A(const gapic::StaticArray<VkOffset3D, 2>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 2; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<VkOffset3D, 2> mElements;
    };

    class VkImageBlit: public Encodable {
    public:
        VkImageBlit() = default;
        VkImageBlit(VkImageSubresourceLayers SrcSubresource, VkOffset3D__2__A SrcOffsets, VkImageSubresourceLayers DstSubresource, VkOffset3D__2__A DstOffsets)
                : mSrcSubresource(SrcSubresource)
                , mSrcOffsets(SrcOffsets)
                , mDstSubresource(DstSubresource)
                , mDstOffsets(DstOffsets) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        VkImageSubresourceLayers mSrcSubresource;
        VkOffset3D__2__A mSrcOffsets;
        VkImageSubresourceLayers mDstSubresource;
        VkOffset3D__2__A mDstOffsets;
    };

    class VkImageBlit__S: public Encodable {
    public:
        VkImageBlit__S() = default;
        VkImageBlit__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkImageBlit__P: public Encodable {
    public:
        VkImageBlit__P() = default;
        VkImageBlit__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkImageCopy: public Encodable {
    public:
        VkImageCopy() = default;
        VkImageCopy(VkImageSubresourceLayers SrcSubresource, VkOffset3D SrcOffset, VkImageSubresourceLayers DstSubresource, VkOffset3D DstOffset, VkExtent3D Extent)
                : mSrcSubresource(SrcSubresource)
                , mSrcOffset(SrcOffset)
                , mDstSubresource(DstSubresource)
                , mDstOffset(DstOffset)
                , mExtent(Extent) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        VkImageSubresourceLayers mSrcSubresource;
        VkOffset3D mSrcOffset;
        VkImageSubresourceLayers mDstSubresource;
        VkOffset3D mDstOffset;
        VkExtent3D mExtent;
    };

    class VkImageCopy__S: public Encodable {
    public:
        VkImageCopy__S() = default;
        VkImageCopy__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkImageCopy__P: public Encodable {
    public:
        VkImageCopy__P() = default;
        VkImageCopy__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkImageCreateInfo: public Encodable {
    public:
        VkImageCreateInfo() = default;
        VkImageCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t ImageType, uint32_t Format, VkExtent3D Extent, uint32_t MipLevels, uint32_t ArrayLayers, uint32_t Samples, uint32_t Tiling, uint32_t Usage, uint32_t SharingMode, uint32_t QueueFamilyIndexCount, U32__CP PQueueFamilyIndices, uint32_t InitialLayout)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mImageType(ImageType)
                , mFormat(Format)
                , mExtent(Extent)
                , mMipLevels(MipLevels)
                , mArrayLayers(ArrayLayers)
                , mSamples(Samples)
                , mTiling(Tiling)
                , mUsage(Usage)
                , mSharingMode(SharingMode)
                , mQueueFamilyIndexCount(QueueFamilyIndexCount)
                , mPQueueFamilyIndices(PQueueFamilyIndices)
                , mInitialLayout(InitialLayout) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mImageType;
        uint32_t mFormat;
        VkExtent3D mExtent;
        uint32_t mMipLevels;
        uint32_t mArrayLayers;
        uint32_t mSamples;
        uint32_t mTiling;
        uint32_t mUsage;
        uint32_t mSharingMode;
        uint32_t mQueueFamilyIndexCount;
        U32__CP mPQueueFamilyIndices;
        uint32_t mInitialLayout;
    };

    class VkImageCreateInfo__S: public Encodable {
    public:
        VkImageCreateInfo__S() = default;
        VkImageCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkImageCreateInfo__P: public Encodable {
    public:
        VkImageCreateInfo__P() = default;
        VkImageCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkImageFormatProperties: public Encodable {
    public:
        VkImageFormatProperties() = default;
        VkImageFormatProperties(VkExtent3D MaxExtent, uint32_t MaxMipLevels, uint32_t MaxArrayLayers, uint32_t SampleCounts, uint64_t MaxResourceSize)
                : mMaxExtent(MaxExtent)
                , mMaxMipLevels(MaxMipLevels)
                , mMaxArrayLayers(MaxArrayLayers)
                , mSampleCounts(SampleCounts)
                , mMaxResourceSize(MaxResourceSize) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        VkExtent3D mMaxExtent;
        uint32_t mMaxMipLevels;
        uint32_t mMaxArrayLayers;
        uint32_t mSampleCounts;
        uint64_t mMaxResourceSize;
    };

    class VkImageFormatProperties__S: public Encodable {
    public:
        VkImageFormatProperties__S() = default;
        VkImageFormatProperties__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkImageMemoryBarrier__S: public Encodable {
    public:
        VkImageMemoryBarrier__S() = default;
        VkImageMemoryBarrier__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkImageMemoryBarrier__P: public Encodable {
    public:
        VkImageMemoryBarrier__P() = default;
        VkImageMemoryBarrier__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkImageResolve: public Encodable {
    public:
        VkImageResolve() = default;
        VkImageResolve(VkImageSubresourceLayers SrcSubresource, VkOffset3D SrcOffset, VkImageSubresourceLayers DstSubresource, VkOffset3D DstOffset, VkExtent3D Extent)
                : mSrcSubresource(SrcSubresource)
                , mSrcOffset(SrcOffset)
                , mDstSubresource(DstSubresource)
                , mDstOffset(DstOffset)
                , mExtent(Extent) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        VkImageSubresourceLayers mSrcSubresource;
        VkOffset3D mSrcOffset;
        VkImageSubresourceLayers mDstSubresource;
        VkOffset3D mDstOffset;
        VkExtent3D mExtent;
    };

    class VkImageResolve__S: public Encodable {
    public:
        VkImageResolve__S() = default;
        VkImageResolve__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkImageResolve__P: public Encodable {
    public:
        VkImageResolve__P() = default;
        VkImageResolve__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkImageSubresource: public Encodable {
    public:
        VkImageSubresource() = default;
        VkImageSubresource(uint32_t AspectMask, uint32_t MipLevel, uint32_t ArrayLayer)
                : mAspectMask(AspectMask)
                , mMipLevel(MipLevel)
                , mArrayLayer(ArrayLayer) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mAspectMask);
            e->Uint32(this->mMipLevel);
            e->Uint32(this->mArrayLayer);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mAspectMask;
        uint32_t mMipLevel;
        uint32_t mArrayLayer;
    };

    class VkImageSubresourceRange__S: public Encodable {
    public:
        VkImageSubresourceRange__S() = default;
        VkImageSubresourceRange__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkImageSubresourceRange__P: public Encodable {
    public:
        VkImageSubresourceRange__P() = default;
        VkImageSubresourceRange__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkImageSubresource__S: public Encodable {
    public:
        VkImageSubresource__S() = default;
        VkImageSubresource__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkImageSubresource__P: public Encodable {
    public:
        VkImageSubresource__P() = default;
        VkImageSubresource__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkImageViewCreateInfo: public Encodable {
    public:
        VkImageViewCreateInfo() = default;
        VkImageViewCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint64_t Image, uint32_t ViewType, uint32_t Format, VkComponentMapping Components, VkImageSubresourceRange SubresourceRange)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mImage(Image)
                , mViewType(ViewType)
                , mFormat(Format)
                , mComponents(Components)
                , mSubresourceRange(SubresourceRange) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint64_t mImage;
        uint32_t mViewType;
        uint32_t mFormat;
        VkComponentMapping mComponents;
        VkImageSubresourceRange mSubresourceRange;
    };

    class VkImageViewCreateInfo__S: public Encodable {
    public:
        VkImageViewCreateInfo__S() = default;
        VkImageViewCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkImageViewCreateInfo__P: public Encodable {
    public:
        VkImageViewCreateInfo__P() = default;
        VkImageViewCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkImageView__S: public Encodable {
    public:
        VkImageView__S() = default;
        VkImageView__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkImage__S: public Encodable {
    public:
        VkImage__S() = default;
        VkImage__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkInstanceCreateInfo: public Encodable {
    public:
        VkInstanceCreateInfo() = default;
        VkInstanceCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, VkApplicationInfo__CP PApplicationInfo, uint32_t EnabledLayerCount, Char__CP__CP PpEnabledLayerNames, uint32_t EnabledExtensionCount, Char__CP__CP PpEnabledExtensionNames)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mPApplicationInfo(PApplicationInfo)
                , mEnabledLayerCount(EnabledLayerCount)
                , mPpEnabledLayerNames(PpEnabledLayerNames)
                , mEnabledExtensionCount(EnabledExtensionCount)
                , mPpEnabledExtensionNames(PpEnabledExtensionNames) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        VkApplicationInfo__CP mPApplicationInfo;
        uint32_t mEnabledLayerCount;
        Char__CP__CP mPpEnabledLayerNames;
        uint32_t mEnabledExtensionCount;
        Char__CP__CP mPpEnabledExtensionNames;
    };

    class VkInstanceCreateInfo__S: public Encodable {
    public:
        VkInstanceCreateInfo__S() = default;
        VkInstanceCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkInstanceCreateInfo__P: public Encodable {
    public:
        VkInstanceCreateInfo__P() = default;
        VkInstanceCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkInstance__S: public Encodable {
    public:
        VkInstance__S() = default;
        VkInstance__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkInvalidateMappedMemoryRanges: public Encodable {
    public:
        VkInvalidateMappedMemoryRanges() = default;
        VkInvalidateMappedMemoryRanges(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t MemoryRangeCount, VkMappedMemoryRange__CP PMemoryRanges, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mMemoryRangeCount(MemoryRangeCount)
                , mPMemoryRanges(PMemoryRanges)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint32_t mMemoryRangeCount;
        VkMappedMemoryRange__CP mPMemoryRanges;
        uint32_t mResult;
    };

    class VkLayerProperties: public Encodable {
    public:
        VkLayerProperties() = default;
        VkLayerProperties(Char__256__A LayerName, uint32_t SpecVersion, uint32_t ImplementationVersion, Char__256__A Description)
                : mLayerName(LayerName)
                , mSpecVersion(SpecVersion)
                , mImplementationVersion(ImplementationVersion)
                , mDescription(Description) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        Char__256__A mLayerName;
        uint32_t mSpecVersion;
        uint32_t mImplementationVersion;
        Char__256__A mDescription;
    };

    class VkLayerProperties__S: public Encodable {
    public:
        VkLayerProperties__S() = default;
        VkLayerProperties__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Void__P__P: public Encodable {
    public:
        Void__P__P() = default;
        Void__P__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkMapMemory: public Encodable {
    public:
        VkMapMemory() = default;
        VkMapMemory(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Memory, uint64_t Offset, uint64_t Size, uint32_t Flags, Void__P__P PpData, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mMemory(Memory)
                , mOffset(Offset)
                , mSize(Size)
                , mFlags(Flags)
                , mPpData(PpData)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mMemory;
        uint64_t mOffset;
        uint64_t mSize;
        uint32_t mFlags;
        Void__P__P mPpData;
        uint32_t mResult;
    };

    class VkMappedMemoryRange: public Encodable {
    public:
        VkMappedMemoryRange() = default;
        VkMappedMemoryRange(uint32_t SType, Void__CP PNext, uint64_t Memory, uint64_t Offset, uint64_t Size)
                : mSType(SType)
                , mPNext(PNext)
                , mMemory(Memory)
                , mOffset(Offset)
                , mSize(Size) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint64_t mMemory;
        uint64_t mOffset;
        uint64_t mSize;
    };

    class VkMappedMemoryRange__S: public Encodable {
    public:
        VkMappedMemoryRange__S() = default;
        VkMappedMemoryRange__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkMappedMemoryRange__P: public Encodable {
    public:
        VkMappedMemoryRange__P() = default;
        VkMappedMemoryRange__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkMemoryAllocateInfo: public Encodable {
    public:
        VkMemoryAllocateInfo() = default;
        VkMemoryAllocateInfo(uint32_t SType, Void__CP PNext, uint64_t AllocationSize, uint32_t MemoryTypeIndex)
                : mSType(SType)
                , mPNext(PNext)
                , mAllocationSize(AllocationSize)
                , mMemoryTypeIndex(MemoryTypeIndex) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint64_t mAllocationSize;
        uint32_t mMemoryTypeIndex;
    };

    class VkMemoryAllocateInfo__S: public Encodable {
    public:
        VkMemoryAllocateInfo__S() = default;
        VkMemoryAllocateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkMemoryAllocateInfo__P: public Encodable {
    public:
        VkMemoryAllocateInfo__P() = default;
        VkMemoryAllocateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkMemoryBarrier: public Encodable {
    public:
        VkMemoryBarrier() = default;
        VkMemoryBarrier(uint32_t SType, Void__CP PNext, uint32_t SrcAccessMask, uint32_t DstAccessMask)
                : mSType(SType)
                , mPNext(PNext)
                , mSrcAccessMask(SrcAccessMask)
                , mDstAccessMask(DstAccessMask) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mSrcAccessMask;
        uint32_t mDstAccessMask;
    };

    class VkMemoryBarrier__S: public Encodable {
    public:
        VkMemoryBarrier__S() = default;
        VkMemoryBarrier__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkMemoryBarrier__P: public Encodable {
    public:
        VkMemoryBarrier__P() = default;
        VkMemoryBarrier__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkMemoryRequirements: public Encodable {
    public:
        VkMemoryRequirements() = default;
        VkMemoryRequirements(uint64_t Size, uint64_t Alignment, uint32_t MemoryTypeBits)
                : mSize(Size)
                , mAlignment(Alignment)
                , mMemoryTypeBits(MemoryTypeBits) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mSize);
            e->Uint64(this->mAlignment);
            e->Uint32(this->mMemoryTypeBits);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mSize;
        uint64_t mAlignment;
        uint32_t mMemoryTypeBits;
    };

    class VkMemoryRequirements__S: public Encodable {
    public:
        VkMemoryRequirements__S() = default;
        VkMemoryRequirements__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineCache__CP: public Encodable {
    public:
        VkPipelineCache__CP() = default;
        VkPipelineCache__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkMergePipelineCaches: public Encodable {
    public:
        VkMergePipelineCaches() = default;
        VkMergePipelineCaches(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t DstCache, uint32_t SrcCacheCount, VkPipelineCache__CP PSrcCaches, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mDstCache(DstCache)
                , mSrcCacheCount(SrcCacheCount)
                , mPSrcCaches(PSrcCaches)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mDstCache;
        uint32_t mSrcCacheCount;
        VkPipelineCache__CP mPSrcCaches;
        uint32_t mResult;
    };

    class VkMirSurfaceCreateInfoKHR__S: public Encodable {
    public:
        VkMirSurfaceCreateInfoKHR__S() = default;
        VkMirSurfaceCreateInfoKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkMirSurfaceCreateInfoKHR__P: public Encodable {
    public:
        VkMirSurfaceCreateInfoKHR__P() = default;
        VkMirSurfaceCreateInfoKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class buffer_handle_t: public Encodable {
    public:
        buffer_handle_t() = default;
        buffer_handle_t(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPhysicalDeviceFeatures__S: public Encodable {
    public:
        VkPhysicalDeviceFeatures__S() = default;
        VkPhysicalDeviceFeatures__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPhysicalDeviceLimits: public Encodable {
    public:
        VkPhysicalDeviceLimits() = default;
        VkPhysicalDeviceLimits(uint32_t MaxImageDimension1D, uint32_t MaxImageDimension2D, uint32_t MaxImageDimension3D, uint32_t MaxImageDimensionCube, uint32_t MaxImageArrayLayers, uint32_t MaxTexelBufferElements, uint32_t MaxUniformBufferRange, uint32_t MaxStorageBufferRange, uint32_t MaxPushConstantsSize, uint32_t MaxMemoryAllocationCount, uint32_t MaxSamplerAllocationCount, uint64_t BufferImageGranularity, uint64_t SparseAddressSpaceSize, uint32_t MaxBoundDescriptorSets, uint32_t MaxPerStageDescriptorSamplers, uint32_t MaxPerStageDescriptorUniformBuffers, uint32_t MaxPerStageDescriptorStorageBuffers, uint32_t MaxPerStageDescriptorSampledImages, uint32_t MaxPerStageDescriptorStorageImages, uint32_t MaxPerStageDescriptorInputAttachments, uint32_t MaxPerStageResources, uint32_t MaxDescriptorSetSamplers, uint32_t MaxDescriptorSetUniformBuffers, uint32_t MaxDescriptorSetUniformBuffersDynamic, uint32_t MaxDescriptorSetStorageBuffers, uint32_t MaxDescriptorSetStorageBuffersDynamic, uint32_t MaxDescriptorSetSampledImages, uint32_t MaxDescriptorSetStorageImages, uint32_t MaxDescriptorSetInputAttachments, uint32_t MaxVertexInputAttributes, uint32_t MaxVertexInputBindings, uint32_t MaxVertexInputAttributeOffset, uint32_t MaxVertexInputBindingStride, uint32_t MaxVertexOutputComponents, uint32_t MaxTessellationGenerationLevel, uint32_t MaxTessellationPatchSize, uint32_t MaxTessellationControlPerVertexInputComponents, uint32_t MaxTessellationControlPerVertexOutputComponents, uint32_t MaxTessellationControlPerPatchOutputComponents, uint32_t MaxTessellationControlTotalOutputComponents, uint32_t MaxTessellationEvaluationInputComponents, uint32_t MaxTessellationEvaluationOutputComponents, uint32_t MaxGeometryShaderInvocations, uint32_t MaxGeometryInputComponents, uint32_t MaxGeometryOutputComponents, uint32_t MaxGeometryOutputVertices, uint32_t MaxGeometryTotalOutputComponents, uint32_t MaxFragmentInputComponents, uint32_t MaxFragmentOutputAttachments, uint32_t MaxFragmentDualSrcAttachments, uint32_t MaxFragmentCombinedOutputResources, uint32_t MaxComputeSharedMemorySize, U32__3__A MaxComputeWorkGroupCount, uint32_t MaxComputeWorkGroupInvocations, U32__3__A MaxComputeWorkGroupSize, uint32_t SubPixelPrecisionBits, uint32_t SubTexelPrecisionBits, uint32_t MipmapPrecisionBits, uint32_t MaxDrawIndexedIndexValue, uint32_t MaxDrawIndirectCount, float MaxSamplerLodBias, float MaxSamplerAnisotropy, uint32_t MaxViewports, U32__2__A MaxViewportDimensions, F32__2__A ViewportBoundsRange, uint32_t ViewportSubPixelBits, uint64_t MinMemoryMapAlignment, uint64_t MinTexelBufferOffsetAlignment, uint64_t MinUniformBufferOffsetAlignment, uint64_t MinStorageBufferOffsetAlignment, int32_t MinTexelOffset, uint32_t MaxTexelOffset, int32_t MinTexelGatherOffset, uint32_t MaxTexelGatherOffset, float MinInterpolationOffset, float MaxInterpolationOffset, uint32_t SubPixelInterpolationOffsetBits, uint32_t MaxFramebufferWidth, uint32_t MaxFramebufferHeight, uint32_t MaxFramebufferLayers, uint32_t FramebufferColorSampleCounts, uint32_t FramebufferDepthSampleCounts, uint32_t FramebufferStencilSampleCounts, uint32_t FramebufferNoAttachmentSampleCounts, uint32_t MaxColorAttachments, uint32_t SampledImageColorSampleCounts, uint32_t SampledImageIntegerSampleCounts, uint32_t SampledImageDepthSampleCounts, uint32_t SampledImageStencilSampleCounts, uint32_t StorageImageSampleCounts, uint32_t MaxSampleMaskWords, uint32_t TimestampComputeAndGraphics, float TimestampPeriod, uint32_t MaxClipDistances, uint32_t MaxCullDistances, uint32_t MaxCombinedClipAndCullDistances, uint32_t DiscreteQueuePriorities, F32__2__A PointSizeRange, F32__2__A LineWidthRange, float PointSizeGranularity, float LineWidthGranularity, uint32_t StrictLines, uint32_t StandardSampleLocations, uint64_t OptimalBufferCopyOffsetAlignment, uint64_t OptimalBufferCopyRowPitchAlignment, uint64_t NonCoherentAtomSize)
                : mMaxImageDimension1D(MaxImageDimension1D)
                , mMaxImageDimension2D(MaxImageDimension2D)
                , mMaxImageDimension3D(MaxImageDimension3D)
                , mMaxImageDimensionCube(MaxImageDimensionCube)
                , mMaxImageArrayLayers(MaxImageArrayLayers)
                , mMaxTexelBufferElements(MaxTexelBufferElements)
                , mMaxUniformBufferRange(MaxUniformBufferRange)
                , mMaxStorageBufferRange(MaxStorageBufferRange)
                , mMaxPushConstantsSize(MaxPushConstantsSize)
                , mMaxMemoryAllocationCount(MaxMemoryAllocationCount)
                , mMaxSamplerAllocationCount(MaxSamplerAllocationCount)
                , mBufferImageGranularity(BufferImageGranularity)
                , mSparseAddressSpaceSize(SparseAddressSpaceSize)
                , mMaxBoundDescriptorSets(MaxBoundDescriptorSets)
                , mMaxPerStageDescriptorSamplers(MaxPerStageDescriptorSamplers)
                , mMaxPerStageDescriptorUniformBuffers(MaxPerStageDescriptorUniformBuffers)
                , mMaxPerStageDescriptorStorageBuffers(MaxPerStageDescriptorStorageBuffers)
                , mMaxPerStageDescriptorSampledImages(MaxPerStageDescriptorSampledImages)
                , mMaxPerStageDescriptorStorageImages(MaxPerStageDescriptorStorageImages)
                , mMaxPerStageDescriptorInputAttachments(MaxPerStageDescriptorInputAttachments)
                , mMaxPerStageResources(MaxPerStageResources)
                , mMaxDescriptorSetSamplers(MaxDescriptorSetSamplers)
                , mMaxDescriptorSetUniformBuffers(MaxDescriptorSetUniformBuffers)
                , mMaxDescriptorSetUniformBuffersDynamic(MaxDescriptorSetUniformBuffersDynamic)
                , mMaxDescriptorSetStorageBuffers(MaxDescriptorSetStorageBuffers)
                , mMaxDescriptorSetStorageBuffersDynamic(MaxDescriptorSetStorageBuffersDynamic)
                , mMaxDescriptorSetSampledImages(MaxDescriptorSetSampledImages)
                , mMaxDescriptorSetStorageImages(MaxDescriptorSetStorageImages)
                , mMaxDescriptorSetInputAttachments(MaxDescriptorSetInputAttachments)
                , mMaxVertexInputAttributes(MaxVertexInputAttributes)
                , mMaxVertexInputBindings(MaxVertexInputBindings)
                , mMaxVertexInputAttributeOffset(MaxVertexInputAttributeOffset)
                , mMaxVertexInputBindingStride(MaxVertexInputBindingStride)
                , mMaxVertexOutputComponents(MaxVertexOutputComponents)
                , mMaxTessellationGenerationLevel(MaxTessellationGenerationLevel)
                , mMaxTessellationPatchSize(MaxTessellationPatchSize)
                , mMaxTessellationControlPerVertexInputComponents(MaxTessellationControlPerVertexInputComponents)
                , mMaxTessellationControlPerVertexOutputComponents(MaxTessellationControlPerVertexOutputComponents)
                , mMaxTessellationControlPerPatchOutputComponents(MaxTessellationControlPerPatchOutputComponents)
                , mMaxTessellationControlTotalOutputComponents(MaxTessellationControlTotalOutputComponents)
                , mMaxTessellationEvaluationInputComponents(MaxTessellationEvaluationInputComponents)
                , mMaxTessellationEvaluationOutputComponents(MaxTessellationEvaluationOutputComponents)
                , mMaxGeometryShaderInvocations(MaxGeometryShaderInvocations)
                , mMaxGeometryInputComponents(MaxGeometryInputComponents)
                , mMaxGeometryOutputComponents(MaxGeometryOutputComponents)
                , mMaxGeometryOutputVertices(MaxGeometryOutputVertices)
                , mMaxGeometryTotalOutputComponents(MaxGeometryTotalOutputComponents)
                , mMaxFragmentInputComponents(MaxFragmentInputComponents)
                , mMaxFragmentOutputAttachments(MaxFragmentOutputAttachments)
                , mMaxFragmentDualSrcAttachments(MaxFragmentDualSrcAttachments)
                , mMaxFragmentCombinedOutputResources(MaxFragmentCombinedOutputResources)
                , mMaxComputeSharedMemorySize(MaxComputeSharedMemorySize)
                , mMaxComputeWorkGroupCount(MaxComputeWorkGroupCount)
                , mMaxComputeWorkGroupInvocations(MaxComputeWorkGroupInvocations)
                , mMaxComputeWorkGroupSize(MaxComputeWorkGroupSize)
                , mSubPixelPrecisionBits(SubPixelPrecisionBits)
                , mSubTexelPrecisionBits(SubTexelPrecisionBits)
                , mMipmapPrecisionBits(MipmapPrecisionBits)
                , mMaxDrawIndexedIndexValue(MaxDrawIndexedIndexValue)
                , mMaxDrawIndirectCount(MaxDrawIndirectCount)
                , mMaxSamplerLodBias(MaxSamplerLodBias)
                , mMaxSamplerAnisotropy(MaxSamplerAnisotropy)
                , mMaxViewports(MaxViewports)
                , mMaxViewportDimensions(MaxViewportDimensions)
                , mViewportBoundsRange(ViewportBoundsRange)
                , mViewportSubPixelBits(ViewportSubPixelBits)
                , mMinMemoryMapAlignment(MinMemoryMapAlignment)
                , mMinTexelBufferOffsetAlignment(MinTexelBufferOffsetAlignment)
                , mMinUniformBufferOffsetAlignment(MinUniformBufferOffsetAlignment)
                , mMinStorageBufferOffsetAlignment(MinStorageBufferOffsetAlignment)
                , mMinTexelOffset(MinTexelOffset)
                , mMaxTexelOffset(MaxTexelOffset)
                , mMinTexelGatherOffset(MinTexelGatherOffset)
                , mMaxTexelGatherOffset(MaxTexelGatherOffset)
                , mMinInterpolationOffset(MinInterpolationOffset)
                , mMaxInterpolationOffset(MaxInterpolationOffset)
                , mSubPixelInterpolationOffsetBits(SubPixelInterpolationOffsetBits)
                , mMaxFramebufferWidth(MaxFramebufferWidth)
                , mMaxFramebufferHeight(MaxFramebufferHeight)
                , mMaxFramebufferLayers(MaxFramebufferLayers)
                , mFramebufferColorSampleCounts(FramebufferColorSampleCounts)
                , mFramebufferDepthSampleCounts(FramebufferDepthSampleCounts)
                , mFramebufferStencilSampleCounts(FramebufferStencilSampleCounts)
                , mFramebufferNoAttachmentSampleCounts(FramebufferNoAttachmentSampleCounts)
                , mMaxColorAttachments(MaxColorAttachments)
                , mSampledImageColorSampleCounts(SampledImageColorSampleCounts)
                , mSampledImageIntegerSampleCounts(SampledImageIntegerSampleCounts)
                , mSampledImageDepthSampleCounts(SampledImageDepthSampleCounts)
                , mSampledImageStencilSampleCounts(SampledImageStencilSampleCounts)
                , mStorageImageSampleCounts(StorageImageSampleCounts)
                , mMaxSampleMaskWords(MaxSampleMaskWords)
                , mTimestampComputeAndGraphics(TimestampComputeAndGraphics)
                , mTimestampPeriod(TimestampPeriod)
                , mMaxClipDistances(MaxClipDistances)
                , mMaxCullDistances(MaxCullDistances)
                , mMaxCombinedClipAndCullDistances(MaxCombinedClipAndCullDistances)
                , mDiscreteQueuePriorities(DiscreteQueuePriorities)
                , mPointSizeRange(PointSizeRange)
                , mLineWidthRange(LineWidthRange)
                , mPointSizeGranularity(PointSizeGranularity)
                , mLineWidthGranularity(LineWidthGranularity)
                , mStrictLines(StrictLines)
                , mStandardSampleLocations(StandardSampleLocations)
                , mOptimalBufferCopyOffsetAlignment(OptimalBufferCopyOffsetAlignment)
                , mOptimalBufferCopyRowPitchAlignment(OptimalBufferCopyRowPitchAlignment)
                , mNonCoherentAtomSize(NonCoherentAtomSize) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mMaxImageDimension1D;
        uint32_t mMaxImageDimension2D;
        uint32_t mMaxImageDimension3D;
        uint32_t mMaxImageDimensionCube;
        uint32_t mMaxImageArrayLayers;
        uint32_t mMaxTexelBufferElements;
        uint32_t mMaxUniformBufferRange;
        uint32_t mMaxStorageBufferRange;
        uint32_t mMaxPushConstantsSize;
        uint32_t mMaxMemoryAllocationCount;
        uint32_t mMaxSamplerAllocationCount;
        uint64_t mBufferImageGranularity;
        uint64_t mSparseAddressSpaceSize;
        uint32_t mMaxBoundDescriptorSets;
        uint32_t mMaxPerStageDescriptorSamplers;
        uint32_t mMaxPerStageDescriptorUniformBuffers;
        uint32_t mMaxPerStageDescriptorStorageBuffers;
        uint32_t mMaxPerStageDescriptorSampledImages;
        uint32_t mMaxPerStageDescriptorStorageImages;
        uint32_t mMaxPerStageDescriptorInputAttachments;
        uint32_t mMaxPerStageResources;
        uint32_t mMaxDescriptorSetSamplers;
        uint32_t mMaxDescriptorSetUniformBuffers;
        uint32_t mMaxDescriptorSetUniformBuffersDynamic;
        uint32_t mMaxDescriptorSetStorageBuffers;
        uint32_t mMaxDescriptorSetStorageBuffersDynamic;
        uint32_t mMaxDescriptorSetSampledImages;
        uint32_t mMaxDescriptorSetStorageImages;
        uint32_t mMaxDescriptorSetInputAttachments;
        uint32_t mMaxVertexInputAttributes;
        uint32_t mMaxVertexInputBindings;
        uint32_t mMaxVertexInputAttributeOffset;
        uint32_t mMaxVertexInputBindingStride;
        uint32_t mMaxVertexOutputComponents;
        uint32_t mMaxTessellationGenerationLevel;
        uint32_t mMaxTessellationPatchSize;
        uint32_t mMaxTessellationControlPerVertexInputComponents;
        uint32_t mMaxTessellationControlPerVertexOutputComponents;
        uint32_t mMaxTessellationControlPerPatchOutputComponents;
        uint32_t mMaxTessellationControlTotalOutputComponents;
        uint32_t mMaxTessellationEvaluationInputComponents;
        uint32_t mMaxTessellationEvaluationOutputComponents;
        uint32_t mMaxGeometryShaderInvocations;
        uint32_t mMaxGeometryInputComponents;
        uint32_t mMaxGeometryOutputComponents;
        uint32_t mMaxGeometryOutputVertices;
        uint32_t mMaxGeometryTotalOutputComponents;
        uint32_t mMaxFragmentInputComponents;
        uint32_t mMaxFragmentOutputAttachments;
        uint32_t mMaxFragmentDualSrcAttachments;
        uint32_t mMaxFragmentCombinedOutputResources;
        uint32_t mMaxComputeSharedMemorySize;
        U32__3__A mMaxComputeWorkGroupCount;
        uint32_t mMaxComputeWorkGroupInvocations;
        U32__3__A mMaxComputeWorkGroupSize;
        uint32_t mSubPixelPrecisionBits;
        uint32_t mSubTexelPrecisionBits;
        uint32_t mMipmapPrecisionBits;
        uint32_t mMaxDrawIndexedIndexValue;
        uint32_t mMaxDrawIndirectCount;
        float mMaxSamplerLodBias;
        float mMaxSamplerAnisotropy;
        uint32_t mMaxViewports;
        U32__2__A mMaxViewportDimensions;
        F32__2__A mViewportBoundsRange;
        uint32_t mViewportSubPixelBits;
        uint64_t mMinMemoryMapAlignment;
        uint64_t mMinTexelBufferOffsetAlignment;
        uint64_t mMinUniformBufferOffsetAlignment;
        uint64_t mMinStorageBufferOffsetAlignment;
        int32_t mMinTexelOffset;
        uint32_t mMaxTexelOffset;
        int32_t mMinTexelGatherOffset;
        uint32_t mMaxTexelGatherOffset;
        float mMinInterpolationOffset;
        float mMaxInterpolationOffset;
        uint32_t mSubPixelInterpolationOffsetBits;
        uint32_t mMaxFramebufferWidth;
        uint32_t mMaxFramebufferHeight;
        uint32_t mMaxFramebufferLayers;
        uint32_t mFramebufferColorSampleCounts;
        uint32_t mFramebufferDepthSampleCounts;
        uint32_t mFramebufferStencilSampleCounts;
        uint32_t mFramebufferNoAttachmentSampleCounts;
        uint32_t mMaxColorAttachments;
        uint32_t mSampledImageColorSampleCounts;
        uint32_t mSampledImageIntegerSampleCounts;
        uint32_t mSampledImageDepthSampleCounts;
        uint32_t mSampledImageStencilSampleCounts;
        uint32_t mStorageImageSampleCounts;
        uint32_t mMaxSampleMaskWords;
        uint32_t mTimestampComputeAndGraphics;
        float mTimestampPeriod;
        uint32_t mMaxClipDistances;
        uint32_t mMaxCullDistances;
        uint32_t mMaxCombinedClipAndCullDistances;
        uint32_t mDiscreteQueuePriorities;
        F32__2__A mPointSizeRange;
        F32__2__A mLineWidthRange;
        float mPointSizeGranularity;
        float mLineWidthGranularity;
        uint32_t mStrictLines;
        uint32_t mStandardSampleLocations;
        uint64_t mOptimalBufferCopyOffsetAlignment;
        uint64_t mOptimalBufferCopyRowPitchAlignment;
        uint64_t mNonCoherentAtomSize;
    };

    class VkPhysicalDeviceMemoryProperties__S: public Encodable {
    public:
        VkPhysicalDeviceMemoryProperties__S() = default;
        VkPhysicalDeviceMemoryProperties__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPhysicalDeviceSparseProperties: public Encodable {
    public:
        VkPhysicalDeviceSparseProperties() = default;
        VkPhysicalDeviceSparseProperties(uint32_t ResidencyStandard2DBlockShape, uint32_t ResidencyStandard2DMultisampleBlockShape, uint32_t ResidencyStandard3DBlockShape, uint32_t ResidencyAlignedMipSize, uint32_t ResidencyNonResidentStrict)
                : mResidencyStandard2DBlockShape(ResidencyStandard2DBlockShape)
                , mResidencyStandard2DMultisampleBlockShape(ResidencyStandard2DMultisampleBlockShape)
                , mResidencyStandard3DBlockShape(ResidencyStandard3DBlockShape)
                , mResidencyAlignedMipSize(ResidencyAlignedMipSize)
                , mResidencyNonResidentStrict(ResidencyNonResidentStrict) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mResidencyStandard2DBlockShape;
        uint32_t mResidencyStandard2DMultisampleBlockShape;
        uint32_t mResidencyStandard3DBlockShape;
        uint32_t mResidencyAlignedMipSize;
        uint32_t mResidencyNonResidentStrict;
    };

    class VkPhysicalDeviceProperties: public Encodable {
    public:
        VkPhysicalDeviceProperties() = default;
        VkPhysicalDeviceProperties(uint32_t ApiVersion, uint32_t DriverVersion, uint32_t VendorID, uint32_t DeviceID, uint32_t DeviceType, Char__256__A DeviceName, U8__16__A PipelineCacheUUID, VkPhysicalDeviceLimits Limits, VkPhysicalDeviceSparseProperties SparseProperties)
                : mApiVersion(ApiVersion)
                , mDriverVersion(DriverVersion)
                , mVendorID(VendorID)
                , mDeviceID(DeviceID)
                , mDeviceType(DeviceType)
                , mDeviceName(DeviceName)
                , mPipelineCacheUUID(PipelineCacheUUID)
                , mLimits(Limits)
                , mSparseProperties(SparseProperties) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mApiVersion;
        uint32_t mDriverVersion;
        uint32_t mVendorID;
        uint32_t mDeviceID;
        uint32_t mDeviceType;
        Char__256__A mDeviceName;
        U8__16__A mPipelineCacheUUID;
        VkPhysicalDeviceLimits mLimits;
        VkPhysicalDeviceSparseProperties mSparseProperties;
    };

    class VkPhysicalDeviceProperties__S: public Encodable {
    public:
        VkPhysicalDeviceProperties__S() = default;
        VkPhysicalDeviceProperties__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPhysicalDevice__S: public Encodable {
    public:
        VkPhysicalDevice__S() = default;
        VkPhysicalDevice__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineCacheCreateInfo: public Encodable {
    public:
        VkPipelineCacheCreateInfo() = default;
        VkPipelineCacheCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint64_t InitialDataSize, Void__CP PInitialData)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mInitialDataSize(InitialDataSize)
                , mPInitialData(PInitialData) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint64_t mInitialDataSize;
        Void__CP mPInitialData;
    };

    class VkPipelineCacheCreateInfo__S: public Encodable {
    public:
        VkPipelineCacheCreateInfo__S() = default;
        VkPipelineCacheCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineCacheCreateInfo__P: public Encodable {
    public:
        VkPipelineCacheCreateInfo__P() = default;
        VkPipelineCacheCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineCache__S: public Encodable {
    public:
        VkPipelineCache__S() = default;
        VkPipelineCache__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineColorBlendAttachmentState: public Encodable {
    public:
        VkPipelineColorBlendAttachmentState() = default;
        VkPipelineColorBlendAttachmentState(uint32_t BlendEnable, uint32_t SrcColorBlendFactor, uint32_t DstColorBlendFactor, uint32_t ColorBlendOp, uint32_t SrcAlphaBlendFactor, uint32_t DstAlphaBlendFactor, uint32_t AlphaBlendOp, uint32_t ColorWriteMask)
                : mBlendEnable(BlendEnable)
                , mSrcColorBlendFactor(SrcColorBlendFactor)
                , mDstColorBlendFactor(DstColorBlendFactor)
                , mColorBlendOp(ColorBlendOp)
                , mSrcAlphaBlendFactor(SrcAlphaBlendFactor)
                , mDstAlphaBlendFactor(DstAlphaBlendFactor)
                , mAlphaBlendOp(AlphaBlendOp)
                , mColorWriteMask(ColorWriteMask) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mBlendEnable;
        uint32_t mSrcColorBlendFactor;
        uint32_t mDstColorBlendFactor;
        uint32_t mColorBlendOp;
        uint32_t mSrcAlphaBlendFactor;
        uint32_t mDstAlphaBlendFactor;
        uint32_t mAlphaBlendOp;
        uint32_t mColorWriteMask;
    };

    class VkPipelineColorBlendAttachmentState__S: public Encodable {
    public:
        VkPipelineColorBlendAttachmentState__S() = default;
        VkPipelineColorBlendAttachmentState__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineColorBlendAttachmentState__P: public Encodable {
    public:
        VkPipelineColorBlendAttachmentState__P() = default;
        VkPipelineColorBlendAttachmentState__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineColorBlendAttachmentState__CP: public Encodable {
    public:
        VkPipelineColorBlendAttachmentState__CP() = default;
        VkPipelineColorBlendAttachmentState__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineColorBlendStateCreateInfo: public Encodable {
    public:
        VkPipelineColorBlendStateCreateInfo() = default;
        VkPipelineColorBlendStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t LogicOpEnable, uint32_t LogicOp, uint32_t AttachmentCount, VkPipelineColorBlendAttachmentState__CP PAttachments, F32__4__A BlendConstants)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mLogicOpEnable(LogicOpEnable)
                , mLogicOp(LogicOp)
                , mAttachmentCount(AttachmentCount)
                , mPAttachments(PAttachments)
                , mBlendConstants(BlendConstants) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mLogicOpEnable;
        uint32_t mLogicOp;
        uint32_t mAttachmentCount;
        VkPipelineColorBlendAttachmentState__CP mPAttachments;
        F32__4__A mBlendConstants;
    };

    class VkPipelineColorBlendStateCreateInfo__S: public Encodable {
    public:
        VkPipelineColorBlendStateCreateInfo__S() = default;
        VkPipelineColorBlendStateCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineColorBlendStateCreateInfo__P: public Encodable {
    public:
        VkPipelineColorBlendStateCreateInfo__P() = default;
        VkPipelineColorBlendStateCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkStencilOpState: public Encodable {
    public:
        VkStencilOpState() = default;
        VkStencilOpState(uint32_t FailOp, uint32_t PassOp, uint32_t DepthFailOp, uint32_t CompareOp, uint32_t CompareMask, uint32_t WriteMask, uint32_t Reference)
                : mFailOp(FailOp)
                , mPassOp(PassOp)
                , mDepthFailOp(DepthFailOp)
                , mCompareOp(CompareOp)
                , mCompareMask(CompareMask)
                , mWriteMask(WriteMask)
                , mReference(Reference) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mFailOp;
        uint32_t mPassOp;
        uint32_t mDepthFailOp;
        uint32_t mCompareOp;
        uint32_t mCompareMask;
        uint32_t mWriteMask;
        uint32_t mReference;
    };

    class VkPipelineDepthStencilStateCreateInfo: public Encodable {
    public:
        VkPipelineDepthStencilStateCreateInfo() = default;
        VkPipelineDepthStencilStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t DepthTestEnable, uint32_t DepthWriteEnable, uint32_t DepthCompareOp, uint32_t DepthBoundsTestEnable, uint32_t StencilTestEnable, VkStencilOpState Front, VkStencilOpState Back, float MinDepthBounds, float MaxDepthBounds)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mDepthTestEnable(DepthTestEnable)
                , mDepthWriteEnable(DepthWriteEnable)
                , mDepthCompareOp(DepthCompareOp)
                , mDepthBoundsTestEnable(DepthBoundsTestEnable)
                , mStencilTestEnable(StencilTestEnable)
                , mFront(Front)
                , mBack(Back)
                , mMinDepthBounds(MinDepthBounds)
                , mMaxDepthBounds(MaxDepthBounds) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mDepthTestEnable;
        uint32_t mDepthWriteEnable;
        uint32_t mDepthCompareOp;
        uint32_t mDepthBoundsTestEnable;
        uint32_t mStencilTestEnable;
        VkStencilOpState mFront;
        VkStencilOpState mBack;
        float mMinDepthBounds;
        float mMaxDepthBounds;
    };

    class VkPipelineDepthStencilStateCreateInfo__S: public Encodable {
    public:
        VkPipelineDepthStencilStateCreateInfo__S() = default;
        VkPipelineDepthStencilStateCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineDepthStencilStateCreateInfo__P: public Encodable {
    public:
        VkPipelineDepthStencilStateCreateInfo__P() = default;
        VkPipelineDepthStencilStateCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineDynamicStateCreateInfo: public Encodable {
    public:
        VkPipelineDynamicStateCreateInfo() = default;
        VkPipelineDynamicStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t DynamicStateCount, VkDynamicState__CP PDynamicStates)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mDynamicStateCount(DynamicStateCount)
                , mPDynamicStates(PDynamicStates) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mDynamicStateCount;
        VkDynamicState__CP mPDynamicStates;
    };

    class VkPipelineDynamicStateCreateInfo__S: public Encodable {
    public:
        VkPipelineDynamicStateCreateInfo__S() = default;
        VkPipelineDynamicStateCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineDynamicStateCreateInfo__P: public Encodable {
    public:
        VkPipelineDynamicStateCreateInfo__P() = default;
        VkPipelineDynamicStateCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineInputAssemblyStateCreateInfo: public Encodable {
    public:
        VkPipelineInputAssemblyStateCreateInfo() = default;
        VkPipelineInputAssemblyStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t Topology, uint32_t PrimitiveRestartEnable)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mTopology(Topology)
                , mPrimitiveRestartEnable(PrimitiveRestartEnable) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mTopology;
        uint32_t mPrimitiveRestartEnable;
    };

    class VkPipelineInputAssemblyStateCreateInfo__S: public Encodable {
    public:
        VkPipelineInputAssemblyStateCreateInfo__S() = default;
        VkPipelineInputAssemblyStateCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineInputAssemblyStateCreateInfo__P: public Encodable {
    public:
        VkPipelineInputAssemblyStateCreateInfo__P() = default;
        VkPipelineInputAssemblyStateCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPushConstantRange__CP: public Encodable {
    public:
        VkPushConstantRange__CP() = default;
        VkPushConstantRange__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineLayoutCreateInfo: public Encodable {
    public:
        VkPipelineLayoutCreateInfo() = default;
        VkPipelineLayoutCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t SetLayoutCount, VkDescriptorSetLayout__CP PSetLayouts, uint32_t PushConstantRangeCount, VkPushConstantRange__CP PPushConstantRanges)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mSetLayoutCount(SetLayoutCount)
                , mPSetLayouts(PSetLayouts)
                , mPushConstantRangeCount(PushConstantRangeCount)
                , mPPushConstantRanges(PPushConstantRanges) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mSetLayoutCount;
        VkDescriptorSetLayout__CP mPSetLayouts;
        uint32_t mPushConstantRangeCount;
        VkPushConstantRange__CP mPPushConstantRanges;
    };

    class VkPipelineLayoutCreateInfo__S: public Encodable {
    public:
        VkPipelineLayoutCreateInfo__S() = default;
        VkPipelineLayoutCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineLayoutCreateInfo__P: public Encodable {
    public:
        VkPipelineLayoutCreateInfo__P() = default;
        VkPipelineLayoutCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineLayout__S: public Encodable {
    public:
        VkPipelineLayout__S() = default;
        VkPipelineLayout__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSampleMask__CP: public Encodable {
    public:
        VkSampleMask__CP() = default;
        VkSampleMask__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineMultisampleStateCreateInfo: public Encodable {
    public:
        VkPipelineMultisampleStateCreateInfo() = default;
        VkPipelineMultisampleStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t RasterizationSamples, uint32_t SampleShadingEnable, float MinSampleShading, VkSampleMask__CP PSampleMask, uint32_t AlphaToCoverageEnable, uint32_t AlphaToOneEnable)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mRasterizationSamples(RasterizationSamples)
                , mSampleShadingEnable(SampleShadingEnable)
                , mMinSampleShading(MinSampleShading)
                , mPSampleMask(PSampleMask)
                , mAlphaToCoverageEnable(AlphaToCoverageEnable)
                , mAlphaToOneEnable(AlphaToOneEnable) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mRasterizationSamples;
        uint32_t mSampleShadingEnable;
        float mMinSampleShading;
        VkSampleMask__CP mPSampleMask;
        uint32_t mAlphaToCoverageEnable;
        uint32_t mAlphaToOneEnable;
    };

    class VkPipelineMultisampleStateCreateInfo__S: public Encodable {
    public:
        VkPipelineMultisampleStateCreateInfo__S() = default;
        VkPipelineMultisampleStateCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineMultisampleStateCreateInfo__P: public Encodable {
    public:
        VkPipelineMultisampleStateCreateInfo__P() = default;
        VkPipelineMultisampleStateCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineRasterizationStateCreateInfo: public Encodable {
    public:
        VkPipelineRasterizationStateCreateInfo() = default;
        VkPipelineRasterizationStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t DepthClampEnable, uint32_t RasterizerDiscardEnable, uint32_t PolygonMode, uint32_t CullMode, uint32_t FrontFace, uint32_t DepthBiasEnable, float DepthBiasConstantFactor, float DepthBiasClamp, float DepthBiasSlopeFactor, float LineWidth)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mDepthClampEnable(DepthClampEnable)
                , mRasterizerDiscardEnable(RasterizerDiscardEnable)
                , mPolygonMode(PolygonMode)
                , mCullMode(CullMode)
                , mFrontFace(FrontFace)
                , mDepthBiasEnable(DepthBiasEnable)
                , mDepthBiasConstantFactor(DepthBiasConstantFactor)
                , mDepthBiasClamp(DepthBiasClamp)
                , mDepthBiasSlopeFactor(DepthBiasSlopeFactor)
                , mLineWidth(LineWidth) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mDepthClampEnable;
        uint32_t mRasterizerDiscardEnable;
        uint32_t mPolygonMode;
        uint32_t mCullMode;
        uint32_t mFrontFace;
        uint32_t mDepthBiasEnable;
        float mDepthBiasConstantFactor;
        float mDepthBiasClamp;
        float mDepthBiasSlopeFactor;
        float mLineWidth;
    };

    class VkPipelineRasterizationStateCreateInfo__S: public Encodable {
    public:
        VkPipelineRasterizationStateCreateInfo__S() = default;
        VkPipelineRasterizationStateCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineRasterizationStateCreateInfo__P: public Encodable {
    public:
        VkPipelineRasterizationStateCreateInfo__P() = default;
        VkPipelineRasterizationStateCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineShaderStageCreateInfo__S: public Encodable {
    public:
        VkPipelineShaderStageCreateInfo__S() = default;
        VkPipelineShaderStageCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineShaderStageCreateInfo__P: public Encodable {
    public:
        VkPipelineShaderStageCreateInfo__P() = default;
        VkPipelineShaderStageCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineStageFlags__S: public Encodable {
    public:
        VkPipelineStageFlags__S() = default;
        VkPipelineStageFlags__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineStageFlags__P: public Encodable {
    public:
        VkPipelineStageFlags__P() = default;
        VkPipelineStageFlags__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineStageFlags__CP: public Encodable {
    public:
        VkPipelineStageFlags__CP() = default;
        VkPipelineStageFlags__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineTessellationStateCreateInfo: public Encodable {
    public:
        VkPipelineTessellationStateCreateInfo() = default;
        VkPipelineTessellationStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t PatchControlPoints)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mPatchControlPoints(PatchControlPoints) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mPatchControlPoints;
    };

    class VkPipelineTessellationStateCreateInfo__S: public Encodable {
    public:
        VkPipelineTessellationStateCreateInfo__S() = default;
        VkPipelineTessellationStateCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineTessellationStateCreateInfo__P: public Encodable {
    public:
        VkPipelineTessellationStateCreateInfo__P() = default;
        VkPipelineTessellationStateCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkVertexInputBindingDescription__CP: public Encodable {
    public:
        VkVertexInputBindingDescription__CP() = default;
        VkVertexInputBindingDescription__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkVertexInputAttributeDescription__CP: public Encodable {
    public:
        VkVertexInputAttributeDescription__CP() = default;
        VkVertexInputAttributeDescription__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineVertexInputStateCreateInfo: public Encodable {
    public:
        VkPipelineVertexInputStateCreateInfo() = default;
        VkPipelineVertexInputStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t VertexBindingDescriptionCount, VkVertexInputBindingDescription__CP PVertexBindingDescriptions, uint32_t VertexAttributeDescriptionCount, VkVertexInputAttributeDescription__CP PVertexAttributeDescriptions)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mVertexBindingDescriptionCount(VertexBindingDescriptionCount)
                , mPVertexBindingDescriptions(PVertexBindingDescriptions)
                , mVertexAttributeDescriptionCount(VertexAttributeDescriptionCount)
                , mPVertexAttributeDescriptions(PVertexAttributeDescriptions) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mVertexBindingDescriptionCount;
        VkVertexInputBindingDescription__CP mPVertexBindingDescriptions;
        uint32_t mVertexAttributeDescriptionCount;
        VkVertexInputAttributeDescription__CP mPVertexAttributeDescriptions;
    };

    class VkPipelineVertexInputStateCreateInfo__S: public Encodable {
    public:
        VkPipelineVertexInputStateCreateInfo__S() = default;
        VkPipelineVertexInputStateCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineVertexInputStateCreateInfo__P: public Encodable {
    public:
        VkPipelineVertexInputStateCreateInfo__P() = default;
        VkPipelineVertexInputStateCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipelineViewportStateCreateInfo: public Encodable {
    public:
        VkPipelineViewportStateCreateInfo() = default;
        VkPipelineViewportStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t ViewportCount, VkViewport__CP PViewports, uint32_t ScissorCount, VkRect2D__CP PScissors)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mViewportCount(ViewportCount)
                , mPViewports(PViewports)
                , mScissorCount(ScissorCount)
                , mPScissors(PScissors) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mViewportCount;
        VkViewport__CP mPViewports;
        uint32_t mScissorCount;
        VkRect2D__CP mPScissors;
    };

    class VkPipelineViewportStateCreateInfo__S: public Encodable {
    public:
        VkPipelineViewportStateCreateInfo__S() = default;
        VkPipelineViewportStateCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPipelineViewportStateCreateInfo__P: public Encodable {
    public:
        VkPipelineViewportStateCreateInfo__P() = default;
        VkPipelineViewportStateCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPipeline__S: public Encodable {
    public:
        VkPipeline__S() = default;
        VkPipeline__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSwapchainKHR__CP: public Encodable {
    public:
        VkSwapchainKHR__CP() = default;
        VkSwapchainKHR__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkResult__P: public Encodable {
    public:
        VkResult__P() = default;
        VkResult__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPresentInfoKHR: public Encodable {
    public:
        VkPresentInfoKHR() = default;
        VkPresentInfoKHR(uint32_t SType, Void__CP PNext, uint32_t WaitSemaphoreCount, VkSemaphore__CP PWaitSemaphores, uint32_t SwapchainCount, VkSwapchainKHR__CP PSwapchains, U32__CP PImageIndices, VkResult__P PResults)
                : mSType(SType)
                , mPNext(PNext)
                , mWaitSemaphoreCount(WaitSemaphoreCount)
                , mPWaitSemaphores(PWaitSemaphores)
                , mSwapchainCount(SwapchainCount)
                , mPSwapchains(PSwapchains)
                , mPImageIndices(PImageIndices)
                , mPResults(PResults) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mWaitSemaphoreCount;
        VkSemaphore__CP mPWaitSemaphores;
        uint32_t mSwapchainCount;
        VkSwapchainKHR__CP mPSwapchains;
        U32__CP mPImageIndices;
        VkResult__P mPResults;
    };

    class VkPresentInfoKHR__S: public Encodable {
    public:
        VkPresentInfoKHR__S() = default;
        VkPresentInfoKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPresentInfoKHR__P: public Encodable {
    public:
        VkPresentInfoKHR__P() = default;
        VkPresentInfoKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPresentInfoKHR__CP: public Encodable {
    public:
        VkPresentInfoKHR__CP() = default;
        VkPresentInfoKHR__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkPresentModeKHR__S: public Encodable {
    public:
        VkPresentModeKHR__S() = default;
        VkPresentModeKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPushConstantRange: public Encodable {
    public:
        VkPushConstantRange() = default;
        VkPushConstantRange(uint32_t StageFlags, uint32_t Offset, uint32_t Size)
                : mStageFlags(StageFlags)
                , mOffset(Offset)
                , mSize(Size) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mStageFlags);
            e->Uint32(this->mOffset);
            e->Uint32(this->mSize);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mStageFlags;
        uint32_t mOffset;
        uint32_t mSize;
    };

    class VkPushConstantRange__S: public Encodable {
    public:
        VkPushConstantRange__S() = default;
        VkPushConstantRange__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkPushConstantRange__P: public Encodable {
    public:
        VkPushConstantRange__P() = default;
        VkPushConstantRange__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkQueryPoolCreateInfo: public Encodable {
    public:
        VkQueryPoolCreateInfo() = default;
        VkQueryPoolCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t QueryType, uint32_t QueryCount, uint32_t PipelineStatistics)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mQueryType(QueryType)
                , mQueryCount(QueryCount)
                , mPipelineStatistics(PipelineStatistics) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mQueryType;
        uint32_t mQueryCount;
        uint32_t mPipelineStatistics;
    };

    class VkQueryPoolCreateInfo__S: public Encodable {
    public:
        VkQueryPoolCreateInfo__S() = default;
        VkQueryPoolCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkQueryPoolCreateInfo__P: public Encodable {
    public:
        VkQueryPoolCreateInfo__P() = default;
        VkQueryPoolCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkQueryPool__S: public Encodable {
    public:
        VkQueryPool__S() = default;
        VkQueryPool__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkQueueBindSparse: public Encodable {
    public:
        VkQueueBindSparse() = default;
        VkQueueBindSparse(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Queue, uint32_t BindInfoCount, VkBindSparseInfo__CP PBindInfo, uint64_t Fence, uint32_t Result)
                : mextras(extras)
                , mQueue(Queue)
                , mBindInfoCount(BindInfoCount)
                , mPBindInfo(PBindInfo)
                , mFence(Fence)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mQueue;
        uint32_t mBindInfoCount;
        VkBindSparseInfo__CP mPBindInfo;
        uint64_t mFence;
        uint32_t mResult;
    };

    class VkQueueFamilyProperties: public Encodable {
    public:
        VkQueueFamilyProperties() = default;
        VkQueueFamilyProperties(uint32_t QueueFlags, uint32_t QueueCount, uint32_t TimestampValidBits, VkExtent3D MinImageTransferGranularity)
                : mQueueFlags(QueueFlags)
                , mQueueCount(QueueCount)
                , mTimestampValidBits(TimestampValidBits)
                , mMinImageTransferGranularity(MinImageTransferGranularity) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mQueueFlags;
        uint32_t mQueueCount;
        uint32_t mTimestampValidBits;
        VkExtent3D mMinImageTransferGranularity;
    };

    class VkQueueFamilyProperties__S: public Encodable {
    public:
        VkQueueFamilyProperties__S() = default;
        VkQueueFamilyProperties__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkQueuePresentKHR: public Encodable {
    public:
        VkQueuePresentKHR() = default;
        VkQueuePresentKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Queue, VkPresentInfoKHR__CP PPresentInfo, uint32_t Result)
                : mextras(extras)
                , mQueue(Queue)
                , mPPresentInfo(PPresentInfo)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mQueue;
        VkPresentInfoKHR__CP mPPresentInfo;
        uint32_t mResult;
    };

    class VkQueueSignalReleaseImageANDROID: public Encodable {
    public:
        VkQueueSignalReleaseImageANDROID() = default;
        VkQueueSignalReleaseImageANDROID(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Queue, uint32_t WaitSemaphoreCount, VkSemaphore__CP PWaitSemaphores, uint64_t Image, Int__P PNativeFenceFd, uint32_t Result)
                : mextras(extras)
                , mQueue(Queue)
                , mWaitSemaphoreCount(WaitSemaphoreCount)
                , mPWaitSemaphores(PWaitSemaphores)
                , mImage(Image)
                , mPNativeFenceFd(PNativeFenceFd)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mQueue;
        uint32_t mWaitSemaphoreCount;
        VkSemaphore__CP mPWaitSemaphores;
        uint64_t mImage;
        Int__P mPNativeFenceFd;
        uint32_t mResult;
    };

    class VkSubmitInfo__CP: public Encodable {
    public:
        VkSubmitInfo__CP() = default;
        VkSubmitInfo__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkQueueSubmit: public Encodable {
    public:
        VkQueueSubmit() = default;
        VkQueueSubmit(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Queue, uint32_t SubmitCount, VkSubmitInfo__CP PSubmits, uint64_t Fence, uint32_t Result)
                : mextras(extras)
                , mQueue(Queue)
                , mSubmitCount(SubmitCount)
                , mPSubmits(PSubmits)
                , mFence(Fence)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mQueue;
        uint32_t mSubmitCount;
        VkSubmitInfo__CP mPSubmits;
        uint64_t mFence;
        uint32_t mResult;
    };

    class VkQueueWaitIdle: public Encodable {
    public:
        VkQueueWaitIdle() = default;
        VkQueueWaitIdle(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Queue, uint32_t Result)
                : mextras(extras)
                , mQueue(Queue)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mQueue);
            e->Uint32(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mQueue;
        uint32_t mResult;
    };

    class VkQueue__S: public Encodable {
    public:
        VkQueue__S() = default;
        VkQueue__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkRect2D__S: public Encodable {
    public:
        VkRect2D__S() = default;
        VkRect2D__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkRect2D__P: public Encodable {
    public:
        VkRect2D__P() = default;
        VkRect2D__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkRenderPassBeginInfo: public Encodable {
    public:
        VkRenderPassBeginInfo() = default;
        VkRenderPassBeginInfo(uint32_t SType, Void__CP PNext, uint64_t RenderPass, uint64_t Framebuffer, VkRect2D RenderArea, uint32_t ClearValueCount, VkClearValue__CP PClearValues)
                : mSType(SType)
                , mPNext(PNext)
                , mRenderPass(RenderPass)
                , mFramebuffer(Framebuffer)
                , mRenderArea(RenderArea)
                , mClearValueCount(ClearValueCount)
                , mPClearValues(PClearValues) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint64_t mRenderPass;
        uint64_t mFramebuffer;
        VkRect2D mRenderArea;
        uint32_t mClearValueCount;
        VkClearValue__CP mPClearValues;
    };

    class VkRenderPassBeginInfo__S: public Encodable {
    public:
        VkRenderPassBeginInfo__S() = default;
        VkRenderPassBeginInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkRenderPassBeginInfo__P: public Encodable {
    public:
        VkRenderPassBeginInfo__P() = default;
        VkRenderPassBeginInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSubpassDescription__CP: public Encodable {
    public:
        VkSubpassDescription__CP() = default;
        VkSubpassDescription__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSubpassDependency__CP: public Encodable {
    public:
        VkSubpassDependency__CP() = default;
        VkSubpassDependency__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkRenderPassCreateInfo: public Encodable {
    public:
        VkRenderPassCreateInfo() = default;
        VkRenderPassCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t AttachmentCount, VkAttachmentDescription__CP PAttachments, uint32_t SubpassCount, VkSubpassDescription__CP PSubpasses, uint32_t DependencyCount, VkSubpassDependency__CP PDependencies)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mAttachmentCount(AttachmentCount)
                , mPAttachments(PAttachments)
                , mSubpassCount(SubpassCount)
                , mPSubpasses(PSubpasses)
                , mDependencyCount(DependencyCount)
                , mPDependencies(PDependencies) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mAttachmentCount;
        VkAttachmentDescription__CP mPAttachments;
        uint32_t mSubpassCount;
        VkSubpassDescription__CP mPSubpasses;
        uint32_t mDependencyCount;
        VkSubpassDependency__CP mPDependencies;
    };

    class VkRenderPassCreateInfo__S: public Encodable {
    public:
        VkRenderPassCreateInfo__S() = default;
        VkRenderPassCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkRenderPassCreateInfo__P: public Encodable {
    public:
        VkRenderPassCreateInfo__P() = default;
        VkRenderPassCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkRenderPass__S: public Encodable {
    public:
        VkRenderPass__S() = default;
        VkRenderPass__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkResetCommandBuffer: public Encodable {
    public:
        VkResetCommandBuffer() = default;
        VkResetCommandBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t Flags, uint32_t Result)
                : mextras(extras)
                , mCommandBuffer(CommandBuffer)
                , mFlags(Flags)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mCommandBuffer;
        uint32_t mFlags;
        uint32_t mResult;
    };

    class VkResetCommandPool: public Encodable {
    public:
        VkResetCommandPool() = default;
        VkResetCommandPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t CommandPool, uint32_t Flags, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mCommandPool(CommandPool)
                , mFlags(Flags)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mCommandPool;
        uint32_t mFlags;
        uint32_t mResult;
    };

    class VkResetDescriptorPool: public Encodable {
    public:
        VkResetDescriptorPool() = default;
        VkResetDescriptorPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t DescriptorPool, uint32_t Flags, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mDescriptorPool(DescriptorPool)
                , mFlags(Flags)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mDescriptorPool;
        uint32_t mFlags;
        uint32_t mResult;
    };

    class VkResetEvent: public Encodable {
    public:
        VkResetEvent() = default;
        VkResetEvent(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Event, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mEvent(Event)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mEvent;
        uint32_t mResult;
    };

    class VkResetFences: public Encodable {
    public:
        VkResetFences() = default;
        VkResetFences(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t FenceCount, VkFence__CP PFences, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mFenceCount(FenceCount)
                , mPFences(PFences)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint32_t mFenceCount;
        VkFence__CP mPFences;
        uint32_t mResult;
    };

    class VkResult__S: public Encodable {
    public:
        VkResult__S() = default;
        VkResult__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSampleMask__S: public Encodable {
    public:
        VkSampleMask__S() = default;
        VkSampleMask__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSampleMask__P: public Encodable {
    public:
        VkSampleMask__P() = default;
        VkSampleMask__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSamplerCreateInfo: public Encodable {
    public:
        VkSamplerCreateInfo() = default;
        VkSamplerCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t MagFilter, uint32_t MinFilter, uint32_t MipmapMode, uint32_t AddressModeU, uint32_t AddressModeV, uint32_t AddressModeW, float MipLodBias, uint32_t AnisotropyEnable, float MaxAnisotropy, uint32_t CompareEnable, uint32_t CompareOp, float MinLod, float MaxLod, uint32_t BorderColor, uint32_t UnnormalizedCoordinates)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mMagFilter(MagFilter)
                , mMinFilter(MinFilter)
                , mMipmapMode(MipmapMode)
                , mAddressModeU(AddressModeU)
                , mAddressModeV(AddressModeV)
                , mAddressModeW(AddressModeW)
                , mMipLodBias(MipLodBias)
                , mAnisotropyEnable(AnisotropyEnable)
                , mMaxAnisotropy(MaxAnisotropy)
                , mCompareEnable(CompareEnable)
                , mCompareOp(CompareOp)
                , mMinLod(MinLod)
                , mMaxLod(MaxLod)
                , mBorderColor(BorderColor)
                , mUnnormalizedCoordinates(UnnormalizedCoordinates) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint32_t mMagFilter;
        uint32_t mMinFilter;
        uint32_t mMipmapMode;
        uint32_t mAddressModeU;
        uint32_t mAddressModeV;
        uint32_t mAddressModeW;
        float mMipLodBias;
        uint32_t mAnisotropyEnable;
        float mMaxAnisotropy;
        uint32_t mCompareEnable;
        uint32_t mCompareOp;
        float mMinLod;
        float mMaxLod;
        uint32_t mBorderColor;
        uint32_t mUnnormalizedCoordinates;
    };

    class VkSamplerCreateInfo__S: public Encodable {
    public:
        VkSamplerCreateInfo__S() = default;
        VkSamplerCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSamplerCreateInfo__P: public Encodable {
    public:
        VkSamplerCreateInfo__P() = default;
        VkSamplerCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSampler__S: public Encodable {
    public:
        VkSampler__S() = default;
        VkSampler__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSemaphoreCreateInfo: public Encodable {
    public:
        VkSemaphoreCreateInfo() = default;
        VkSemaphoreCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mSType);
            e->Struct(this->mPNext);
            e->Uint32(this->mFlags);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
    };

    class VkSemaphoreCreateInfo__S: public Encodable {
    public:
        VkSemaphoreCreateInfo__S() = default;
        VkSemaphoreCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSemaphoreCreateInfo__P: public Encodable {
    public:
        VkSemaphoreCreateInfo__P() = default;
        VkSemaphoreCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSemaphore__S: public Encodable {
    public:
        VkSemaphore__S() = default;
        VkSemaphore__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSetEvent: public Encodable {
    public:
        VkSetEvent() = default;
        VkSetEvent(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Event, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mEvent(Event)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mEvent;
        uint32_t mResult;
    };

    class VkShaderModuleCreateInfo: public Encodable {
    public:
        VkShaderModuleCreateInfo() = default;
        VkShaderModuleCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint64_t CodeSize, U32__CP PCode)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mCodeSize(CodeSize)
                , mPCode(PCode) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint64_t mCodeSize;
        U32__CP mPCode;
    };

    class VkShaderModuleCreateInfo__S: public Encodable {
    public:
        VkShaderModuleCreateInfo__S() = default;
        VkShaderModuleCreateInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkShaderModuleCreateInfo__P: public Encodable {
    public:
        VkShaderModuleCreateInfo__P() = default;
        VkShaderModuleCreateInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkShaderModule__S: public Encodable {
    public:
        VkShaderModule__S() = default;
        VkShaderModule__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSparseMemoryBind__CP: public Encodable {
    public:
        VkSparseMemoryBind__CP() = default;
        VkSparseMemoryBind__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSparseBufferMemoryBindInfo: public Encodable {
    public:
        VkSparseBufferMemoryBindInfo() = default;
        VkSparseBufferMemoryBindInfo(uint64_t Buffer, uint32_t BindCount, VkSparseMemoryBind__CP PBinds)
                : mBuffer(Buffer)
                , mBindCount(BindCount)
                , mPBinds(PBinds) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mBuffer);
            e->Uint32(this->mBindCount);
            e->Struct(this->mPBinds);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mBuffer;
        uint32_t mBindCount;
        VkSparseMemoryBind__CP mPBinds;
    };

    class VkSparseBufferMemoryBindInfo__S: public Encodable {
    public:
        VkSparseBufferMemoryBindInfo__S() = default;
        VkSparseBufferMemoryBindInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSparseBufferMemoryBindInfo__P: public Encodable {
    public:
        VkSparseBufferMemoryBindInfo__P() = default;
        VkSparseBufferMemoryBindInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSparseImageFormatProperties: public Encodable {
    public:
        VkSparseImageFormatProperties() = default;
        VkSparseImageFormatProperties(uint32_t AspectMask, VkExtent3D ImageGranularity, uint32_t Flags)
                : mAspectMask(AspectMask)
                , mImageGranularity(ImageGranularity)
                , mFlags(Flags) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mAspectMask);
            e->Struct(this->mImageGranularity);
            e->Uint32(this->mFlags);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mAspectMask;
        VkExtent3D mImageGranularity;
        uint32_t mFlags;
    };

    class VkSparseImageFormatProperties__S: public Encodable {
    public:
        VkSparseImageFormatProperties__S() = default;
        VkSparseImageFormatProperties__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSparseImageMemoryBind: public Encodable {
    public:
        VkSparseImageMemoryBind() = default;
        VkSparseImageMemoryBind(VkImageSubresource Subresource, VkOffset3D Offset, VkExtent3D Extent, uint64_t Memory, uint64_t MemoryOffset, uint32_t Flags)
                : mSubresource(Subresource)
                , mOffset(Offset)
                , mExtent(Extent)
                , mMemory(Memory)
                , mMemoryOffset(MemoryOffset)
                , mFlags(Flags) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        VkImageSubresource mSubresource;
        VkOffset3D mOffset;
        VkExtent3D mExtent;
        uint64_t mMemory;
        uint64_t mMemoryOffset;
        uint32_t mFlags;
    };

    class VkSparseImageMemoryBindInfo: public Encodable {
    public:
        VkSparseImageMemoryBindInfo() = default;
        VkSparseImageMemoryBindInfo(uint64_t Image, uint32_t BindCount, VkSparseMemoryBind__CP PBinds)
                : mImage(Image)
                , mBindCount(BindCount)
                , mPBinds(PBinds) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mImage);
            e->Uint32(this->mBindCount);
            e->Struct(this->mPBinds);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mImage;
        uint32_t mBindCount;
        VkSparseMemoryBind__CP mPBinds;
    };

    class VkSparseImageMemoryBindInfo__S: public Encodable {
    public:
        VkSparseImageMemoryBindInfo__S() = default;
        VkSparseImageMemoryBindInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSparseImageMemoryBindInfo__P: public Encodable {
    public:
        VkSparseImageMemoryBindInfo__P() = default;
        VkSparseImageMemoryBindInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSparseImageMemoryRequirements: public Encodable {
    public:
        VkSparseImageMemoryRequirements() = default;
        VkSparseImageMemoryRequirements(VkSparseImageFormatProperties FormatProperties, uint32_t ImageMipTailFirstLod, uint64_t ImageMipTailSize, uint64_t ImageMipTailOffset, uint64_t ImageMipTailStride)
                : mFormatProperties(FormatProperties)
                , mImageMipTailFirstLod(ImageMipTailFirstLod)
                , mImageMipTailSize(ImageMipTailSize)
                , mImageMipTailOffset(ImageMipTailOffset)
                , mImageMipTailStride(ImageMipTailStride) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        VkSparseImageFormatProperties mFormatProperties;
        uint32_t mImageMipTailFirstLod;
        uint64_t mImageMipTailSize;
        uint64_t mImageMipTailOffset;
        uint64_t mImageMipTailStride;
    };

    class VkSparseImageMemoryRequirements__S: public Encodable {
    public:
        VkSparseImageMemoryRequirements__S() = default;
        VkSparseImageMemoryRequirements__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSparseImageOpaqueMemoryBindInfo: public Encodable {
    public:
        VkSparseImageOpaqueMemoryBindInfo() = default;
        VkSparseImageOpaqueMemoryBindInfo(uint64_t Image, uint32_t BindCount, VkSparseMemoryBind__CP PBinds)
                : mImage(Image)
                , mBindCount(BindCount)
                , mPBinds(PBinds) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mImage);
            e->Uint32(this->mBindCount);
            e->Struct(this->mPBinds);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mImage;
        uint32_t mBindCount;
        VkSparseMemoryBind__CP mPBinds;
    };

    class VkSparseImageOpaqueMemoryBindInfo__S: public Encodable {
    public:
        VkSparseImageOpaqueMemoryBindInfo__S() = default;
        VkSparseImageOpaqueMemoryBindInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSparseImageOpaqueMemoryBindInfo__P: public Encodable {
    public:
        VkSparseImageOpaqueMemoryBindInfo__P() = default;
        VkSparseImageOpaqueMemoryBindInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSparseMemoryBind: public Encodable {
    public:
        VkSparseMemoryBind() = default;
        VkSparseMemoryBind(uint64_t ResourceOffset, uint64_t Size, uint64_t Memory, uint64_t MemoryOffset, uint32_t Flags)
                : mResourceOffset(ResourceOffset)
                , mSize(Size)
                , mMemory(Memory)
                , mMemoryOffset(MemoryOffset)
                , mFlags(Flags) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mResourceOffset;
        uint64_t mSize;
        uint64_t mMemory;
        uint64_t mMemoryOffset;
        uint32_t mFlags;
    };

    class VkSparseMemoryBind__S: public Encodable {
    public:
        VkSparseMemoryBind__S() = default;
        VkSparseMemoryBind__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSparseMemoryBind__P: public Encodable {
    public:
        VkSparseMemoryBind__P() = default;
        VkSparseMemoryBind__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSpecializationMapEntry__CP: public Encodable {
    public:
        VkSpecializationMapEntry__CP() = default;
        VkSpecializationMapEntry__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSpecializationInfo: public Encodable {
    public:
        VkSpecializationInfo() = default;
        VkSpecializationInfo(uint32_t MapEntryCount, VkSpecializationMapEntry__CP PMapEntries, uint64_t DataSize, Void__CP PData)
                : mMapEntryCount(MapEntryCount)
                , mPMapEntries(PMapEntries)
                , mDataSize(DataSize)
                , mPData(PData) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mMapEntryCount;
        VkSpecializationMapEntry__CP mPMapEntries;
        uint64_t mDataSize;
        Void__CP mPData;
    };

    class VkSpecializationInfo__S: public Encodable {
    public:
        VkSpecializationInfo__S() = default;
        VkSpecializationInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSpecializationInfo__P: public Encodable {
    public:
        VkSpecializationInfo__P() = default;
        VkSpecializationInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSpecializationMapEntry: public Encodable {
    public:
        VkSpecializationMapEntry() = default;
        VkSpecializationMapEntry(uint32_t ConstantID, uint32_t Offset, uint64_t Size)
                : mConstantID(ConstantID)
                , mOffset(Offset)
                , mSize(Size) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mConstantID);
            e->Uint32(this->mOffset);
            e->Uint64(this->mSize);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mConstantID;
        uint32_t mOffset;
        uint64_t mSize;
    };

    class VkSpecializationMapEntry__S: public Encodable {
    public:
        VkSpecializationMapEntry__S() = default;
        VkSpecializationMapEntry__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSpecializationMapEntry__P: public Encodable {
    public:
        VkSpecializationMapEntry__P() = default;
        VkSpecializationMapEntry__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSubmitInfo: public Encodable {
    public:
        VkSubmitInfo() = default;
        VkSubmitInfo(uint32_t SType, Void__CP PNext, uint32_t WaitSemaphoreCount, VkSemaphore__CP PWaitSemaphores, VkPipelineStageFlags__CP PWaitDstStageMask, uint32_t CommandBufferCount, VkCommandBuffer__CP PCommandBuffers, uint32_t SignalSemaphoreCount, VkSemaphore__CP PSignalSemaphores)
                : mSType(SType)
                , mPNext(PNext)
                , mWaitSemaphoreCount(WaitSemaphoreCount)
                , mPWaitSemaphores(PWaitSemaphores)
                , mPWaitDstStageMask(PWaitDstStageMask)
                , mCommandBufferCount(CommandBufferCount)
                , mPCommandBuffers(PCommandBuffers)
                , mSignalSemaphoreCount(SignalSemaphoreCount)
                , mPSignalSemaphores(PSignalSemaphores) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mWaitSemaphoreCount;
        VkSemaphore__CP mPWaitSemaphores;
        VkPipelineStageFlags__CP mPWaitDstStageMask;
        uint32_t mCommandBufferCount;
        VkCommandBuffer__CP mPCommandBuffers;
        uint32_t mSignalSemaphoreCount;
        VkSemaphore__CP mPSignalSemaphores;
    };

    class VkSubmitInfo__S: public Encodable {
    public:
        VkSubmitInfo__S() = default;
        VkSubmitInfo__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSubmitInfo__P: public Encodable {
    public:
        VkSubmitInfo__P() = default;
        VkSubmitInfo__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSubpassDependency: public Encodable {
    public:
        VkSubpassDependency() = default;
        VkSubpassDependency(uint32_t SrcSubpass, uint32_t DstSubpass, uint32_t SrcStageMask, uint32_t DstStageMask, uint32_t SrcAccessMask, uint32_t DstAccessMask, uint32_t DependencyFlags)
                : mSrcSubpass(SrcSubpass)
                , mDstSubpass(DstSubpass)
                , mSrcStageMask(SrcStageMask)
                , mDstStageMask(DstStageMask)
                , mSrcAccessMask(SrcAccessMask)
                , mDstAccessMask(DstAccessMask)
                , mDependencyFlags(DependencyFlags) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSrcSubpass;
        uint32_t mDstSubpass;
        uint32_t mSrcStageMask;
        uint32_t mDstStageMask;
        uint32_t mSrcAccessMask;
        uint32_t mDstAccessMask;
        uint32_t mDependencyFlags;
    };

    class VkSubpassDependency__S: public Encodable {
    public:
        VkSubpassDependency__S() = default;
        VkSubpassDependency__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSubpassDependency__P: public Encodable {
    public:
        VkSubpassDependency__P() = default;
        VkSubpassDependency__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSubpassDescription: public Encodable {
    public:
        VkSubpassDescription() = default;
        VkSubpassDescription(uint32_t Flags, uint32_t PipelineBindPoint, uint32_t InputAttachmentCount, VkAttachmentReference__CP PInputAttachments, uint32_t ColorAttachmentCount, VkAttachmentReference__CP PColorAttachments, VkAttachmentReference__CP PResolveAttachments, VkAttachmentReference__CP PDepthStencilAttachment, uint32_t PreserveAttachmentCount, U32__CP PPreserveAttachments)
                : mFlags(Flags)
                , mPipelineBindPoint(PipelineBindPoint)
                , mInputAttachmentCount(InputAttachmentCount)
                , mPInputAttachments(PInputAttachments)
                , mColorAttachmentCount(ColorAttachmentCount)
                , mPColorAttachments(PColorAttachments)
                , mPResolveAttachments(PResolveAttachments)
                , mPDepthStencilAttachment(PDepthStencilAttachment)
                , mPreserveAttachmentCount(PreserveAttachmentCount)
                , mPPreserveAttachments(PPreserveAttachments) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mFlags;
        uint32_t mPipelineBindPoint;
        uint32_t mInputAttachmentCount;
        VkAttachmentReference__CP mPInputAttachments;
        uint32_t mColorAttachmentCount;
        VkAttachmentReference__CP mPColorAttachments;
        VkAttachmentReference__CP mPResolveAttachments;
        VkAttachmentReference__CP mPDepthStencilAttachment;
        uint32_t mPreserveAttachmentCount;
        U32__CP mPPreserveAttachments;
    };

    class VkSubpassDescription__S: public Encodable {
    public:
        VkSubpassDescription__S() = default;
        VkSubpassDescription__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSubpassDescription__P: public Encodable {
    public:
        VkSubpassDescription__P() = default;
        VkSubpassDescription__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSubresourceLayout: public Encodable {
    public:
        VkSubresourceLayout() = default;
        VkSubresourceLayout(uint64_t Offset, uint64_t Size, uint64_t RowPitch, uint64_t ArrayPitch, uint64_t DepthPitch)
                : mOffset(Offset)
                , mSize(Size)
                , mRowPitch(RowPitch)
                , mArrayPitch(ArrayPitch)
                , mDepthPitch(DepthPitch) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mOffset;
        uint64_t mSize;
        uint64_t mRowPitch;
        uint64_t mArrayPitch;
        uint64_t mDepthPitch;
    };

    class VkSubresourceLayout__S: public Encodable {
    public:
        VkSubresourceLayout__S() = default;
        VkSubresourceLayout__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSurfaceCapabilitiesKHR: public Encodable {
    public:
        VkSurfaceCapabilitiesKHR() = default;
        VkSurfaceCapabilitiesKHR(uint32_t MinImageCount, uint32_t MaxImageCount, VkExtent2D CurrentExtent, VkExtent2D MinImageExtent, VkExtent2D MaxImageExtent, uint32_t MaxImageArrayLayers, uint32_t SupportedTransforms, uint32_t CurrentTransform, uint32_t SupportedCompositeAlpha, uint32_t SupportedUsageFlags)
                : mMinImageCount(MinImageCount)
                , mMaxImageCount(MaxImageCount)
                , mCurrentExtent(CurrentExtent)
                , mMinImageExtent(MinImageExtent)
                , mMaxImageExtent(MaxImageExtent)
                , mMaxImageArrayLayers(MaxImageArrayLayers)
                , mSupportedTransforms(SupportedTransforms)
                , mCurrentTransform(CurrentTransform)
                , mSupportedCompositeAlpha(SupportedCompositeAlpha)
                , mSupportedUsageFlags(SupportedUsageFlags) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mMinImageCount;
        uint32_t mMaxImageCount;
        VkExtent2D mCurrentExtent;
        VkExtent2D mMinImageExtent;
        VkExtent2D mMaxImageExtent;
        uint32_t mMaxImageArrayLayers;
        uint32_t mSupportedTransforms;
        uint32_t mCurrentTransform;
        uint32_t mSupportedCompositeAlpha;
        uint32_t mSupportedUsageFlags;
    };

    class VkSurfaceCapabilitiesKHR__S: public Encodable {
    public:
        VkSurfaceCapabilitiesKHR__S() = default;
        VkSurfaceCapabilitiesKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSurfaceFormatKHR: public Encodable {
    public:
        VkSurfaceFormatKHR() = default;
        VkSurfaceFormatKHR(uint32_t Format, uint32_t ColorSpace)
                : mFormat(Format)
                , mColorSpace(ColorSpace) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mFormat);
            e->Uint32(this->mColorSpace);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mFormat;
        uint32_t mColorSpace;
    };

    class VkSurfaceFormatKHR__S: public Encodable {
    public:
        VkSurfaceFormatKHR__S() = default;
        VkSurfaceFormatKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSurfaceKHR__S: public Encodable {
    public:
        VkSurfaceKHR__S() = default;
        VkSurfaceKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSwapchainCreateInfoKHR: public Encodable {
    public:
        VkSwapchainCreateInfoKHR() = default;
        VkSwapchainCreateInfoKHR(uint32_t SType, Void__CP PNext, uint32_t Flags, uint64_t Surface, uint32_t MinImageCount, uint32_t ImageFormat, uint32_t ImageColorSpace, VkExtent2D ImageExtent, uint32_t ImageArrayLayers, uint32_t ImageUsage, uint32_t ImageSharingMode, uint32_t QueueFamilyIndexCount, U32__CP PQueueFamilyIndices, uint32_t PreTransform, uint32_t CompositeAlpha, uint32_t PresentMode, uint32_t Clipped, uint64_t OldSwapchain)
                : mSType(SType)
                , mPNext(PNext)
                , mFlags(Flags)
                , mSurface(Surface)
                , mMinImageCount(MinImageCount)
                , mImageFormat(ImageFormat)
                , mImageColorSpace(ImageColorSpace)
                , mImageExtent(ImageExtent)
                , mImageArrayLayers(ImageArrayLayers)
                , mImageUsage(ImageUsage)
                , mImageSharingMode(ImageSharingMode)
                , mQueueFamilyIndexCount(QueueFamilyIndexCount)
                , mPQueueFamilyIndices(PQueueFamilyIndices)
                , mPreTransform(PreTransform)
                , mCompositeAlpha(CompositeAlpha)
                , mPresentMode(PresentMode)
                , mClipped(Clipped)
                , mOldSwapchain(OldSwapchain) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint32_t mFlags;
        uint64_t mSurface;
        uint32_t mMinImageCount;
        uint32_t mImageFormat;
        uint32_t mImageColorSpace;
        VkExtent2D mImageExtent;
        uint32_t mImageArrayLayers;
        uint32_t mImageUsage;
        uint32_t mImageSharingMode;
        uint32_t mQueueFamilyIndexCount;
        U32__CP mPQueueFamilyIndices;
        uint32_t mPreTransform;
        uint32_t mCompositeAlpha;
        uint32_t mPresentMode;
        uint32_t mClipped;
        uint64_t mOldSwapchain;
    };

    class VkSwapchainCreateInfoKHR__S: public Encodable {
    public:
        VkSwapchainCreateInfoKHR__S() = default;
        VkSwapchainCreateInfoKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkSwapchainCreateInfoKHR__P: public Encodable {
    public:
        VkSwapchainCreateInfoKHR__P() = default;
        VkSwapchainCreateInfoKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkSwapchainKHR__S: public Encodable {
    public:
        VkSwapchainKHR__S() = default;
        VkSwapchainKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkUnmapMemory: public Encodable {
    public:
        VkUnmapMemory() = default;
        VkUnmapMemory(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Memory)
                : mextras(extras)
                , mDevice(Device)
                , mMemory(Memory) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mDevice);
            e->Uint64(this->mMemory);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint64_t mMemory;
    };

    class VkWriteDescriptorSet__CP: public Encodable {
    public:
        VkWriteDescriptorSet__CP() = default;
        VkWriteDescriptorSet__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkUpdateDescriptorSets: public Encodable {
    public:
        VkUpdateDescriptorSets() = default;
        VkUpdateDescriptorSets(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t DescriptorWriteCount, VkWriteDescriptorSet__CP PDescriptorWrites, uint32_t DescriptorCopyCount, VkCopyDescriptorSet__CP PDescriptorCopies)
                : mextras(extras)
                , mDevice(Device)
                , mDescriptorWriteCount(DescriptorWriteCount)
                , mPDescriptorWrites(PDescriptorWrites)
                , mDescriptorCopyCount(DescriptorCopyCount)
                , mPDescriptorCopies(PDescriptorCopies) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint32_t mDescriptorWriteCount;
        VkWriteDescriptorSet__CP mPDescriptorWrites;
        uint32_t mDescriptorCopyCount;
        VkCopyDescriptorSet__CP mPDescriptorCopies;
    };

    class VkVertexInputAttributeDescription: public Encodable {
    public:
        VkVertexInputAttributeDescription() = default;
        VkVertexInputAttributeDescription(uint32_t Location, uint32_t Binding, uint32_t Format, uint32_t Offset)
                : mLocation(Location)
                , mBinding(Binding)
                , mFormat(Format)
                , mOffset(Offset) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mLocation;
        uint32_t mBinding;
        uint32_t mFormat;
        uint32_t mOffset;
    };

    class VkVertexInputAttributeDescription__S: public Encodable {
    public:
        VkVertexInputAttributeDescription__S() = default;
        VkVertexInputAttributeDescription__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkVertexInputAttributeDescription__P: public Encodable {
    public:
        VkVertexInputAttributeDescription__P() = default;
        VkVertexInputAttributeDescription__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkVertexInputBindingDescription: public Encodable {
    public:
        VkVertexInputBindingDescription() = default;
        VkVertexInputBindingDescription(uint32_t Binding, uint32_t Stride, uint32_t InputRate)
                : mBinding(Binding)
                , mStride(Stride)
                , mInputRate(InputRate) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mBinding);
            e->Uint32(this->mStride);
            e->Uint32(this->mInputRate);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mBinding;
        uint32_t mStride;
        uint32_t mInputRate;
    };

    class VkVertexInputBindingDescription__S: public Encodable {
    public:
        VkVertexInputBindingDescription__S() = default;
        VkVertexInputBindingDescription__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkVertexInputBindingDescription__P: public Encodable {
    public:
        VkVertexInputBindingDescription__P() = default;
        VkVertexInputBindingDescription__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkViewport: public Encodable {
    public:
        VkViewport() = default;
        VkViewport(float X, float Y, float Width, float Height, float MinDepth, float MaxDepth)
                : mX(X)
                , mY(Y)
                , mWidth(Width)
                , mHeight(Height)
                , mMinDepth(MinDepth)
                , mMaxDepth(MaxDepth) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        float mX;
        float mY;
        float mWidth;
        float mHeight;
        float mMinDepth;
        float mMaxDepth;
    };

    class VkViewport__S: public Encodable {
    public:
        VkViewport__S() = default;
        VkViewport__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkViewport__P: public Encodable {
    public:
        VkViewport__P() = default;
        VkViewport__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkWaitForFences: public Encodable {
    public:
        VkWaitForFences() = default;
        VkWaitForFences(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t FenceCount, VkFence__CP PFences, uint32_t WaitAll, uint64_t Timeout, uint32_t Result)
                : mextras(extras)
                , mDevice(Device)
                , mFenceCount(FenceCount)
                , mPFences(PFences)
                , mWaitAll(WaitAll)
                , mTimeout(Timeout)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mDevice;
        uint32_t mFenceCount;
        VkFence__CP mPFences;
        uint32_t mWaitAll;
        uint64_t mTimeout;
        uint32_t mResult;
    };

    class Wl_surface__P: public Encodable {
    public:
        Wl_surface__P() = default;
        Wl_surface__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkWaylandSurfaceCreateInfoKHR__S: public Encodable {
    public:
        VkWaylandSurfaceCreateInfoKHR__S() = default;
        VkWaylandSurfaceCreateInfoKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkWaylandSurfaceCreateInfoKHR__P: public Encodable {
    public:
        VkWaylandSurfaceCreateInfoKHR__P() = default;
        VkWaylandSurfaceCreateInfoKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkWriteDescriptorSet: public Encodable {
    public:
        VkWriteDescriptorSet() = default;
        VkWriteDescriptorSet(uint32_t SType, Void__CP PNext, uint64_t DstSet, uint32_t DstBinding, uint32_t DstArrayElement, uint32_t DescriptorCount, uint32_t DescriptorType, VkDescriptorImageInfo__CP PImageInfo, VkDescriptorBufferInfo__CP PBufferInfo, VkBufferView__CP PTexelBufferView)
                : mSType(SType)
                , mPNext(PNext)
                , mDstSet(DstSet)
                , mDstBinding(DstBinding)
                , mDstArrayElement(DstArrayElement)
                , mDescriptorCount(DescriptorCount)
                , mDescriptorType(DescriptorType)
                , mPImageInfo(PImageInfo)
                , mPBufferInfo(PBufferInfo)
                , mPTexelBufferView(PTexelBufferView) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mSType;
        Void__CP mPNext;
        uint64_t mDstSet;
        uint32_t mDstBinding;
        uint32_t mDstArrayElement;
        uint32_t mDescriptorCount;
        uint32_t mDescriptorType;
        VkDescriptorImageInfo__CP mPImageInfo;
        VkDescriptorBufferInfo__CP mPBufferInfo;
        VkBufferView__CP mPTexelBufferView;
    };

    class VkWriteDescriptorSet__S: public Encodable {
    public:
        VkWriteDescriptorSet__S() = default;
        VkWriteDescriptorSet__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkWriteDescriptorSet__P: public Encodable {
    public:
        VkWriteDescriptorSet__P() = default;
        VkWriteDescriptorSet__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkXcbSurfaceCreateInfoKHR__S: public Encodable {
    public:
        VkXcbSurfaceCreateInfoKHR__S() = default;
        VkXcbSurfaceCreateInfoKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkXcbSurfaceCreateInfoKHR__P: public Encodable {
    public:
        VkXcbSurfaceCreateInfoKHR__P() = default;
        VkXcbSurfaceCreateInfoKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VkXlibSurfaceCreateInfoKHR__S: public Encodable {
    public:
        VkXlibSurfaceCreateInfoKHR__S() = default;
        VkXlibSurfaceCreateInfoKHR__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class VkXlibSurfaceCreateInfoKHR__P: public Encodable {
    public:
        VkXlibSurfaceCreateInfoKHR__P() = default;
        VkXlibSurfaceCreateInfoKHR__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Void__S: public Encodable {
    public:
        Void__S() = default;
        Void__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Void__P__S: public Encodable {
    public:
        Void__P__S() = default;
        Void__P__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Wl_display__S: public Encodable {
    public:
        Wl_display__S() = default;
        Wl_display__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Wl_surface__S: public Encodable {
    public:
        Wl_surface__S() = default;
        Wl_surface__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Xcb_connection_t__S: public Encodable {
    public:
        Xcb_connection_t__S() = default;
        Xcb_connection_t__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };


} // namespace vulkan
} // namespace coder
} // namespace gapic

#endif // GAPIC_CODER_VULKAN_H