cc/gapic/coder/vulkan.cpp

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



#include "vulkan.h"
#include <gapic/schema.h>
namespace gapic {

class Encodable;
class Encoder;

namespace coder {
namespace vulkan {
// ANativeWindowˢ:
// vulkan.ANativeWindowˢ{$}
const schema::Entity* ANativeWindow__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "ANativeWindowˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// ANativeWindowᵖ:
// vulkan.ANativeWindowᵖ{Uint64,Uint32}
const schema::Entity* ANativeWindow__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "ANativeWindowᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// Charː256ᵃ:
// vulkan.Charː256ᵃ{[256]Uint8}
const schema::Entity* Char__256__A::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Charː256ᵃ",
        "",
        {
            schema::Field{"Elements", new schema::Array{"", new schema::Primitive{"gfxapi.Char", schema::Primitive::Uint8}, 256}},
        },
    };
    return &entity;
}

// Charˢ:
// vulkan.Charˢ{$}
const schema::Entity* Char__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Charˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// Charᵖ:
// vulkan.Charᵖ{Uint64,Uint32}
const schema::Entity* Char__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Charᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// Charᶜᵖ:
// vulkan.Charᶜᵖ{Uint64,Uint32}
const schema::Entity* Char__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Charᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// Charᶜᵖˢ:
// vulkan.Charᶜᵖˢ{$}
const schema::Entity* Char__CP__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Charᶜᵖˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// Charᶜᵖᵖ:
// vulkan.Charᶜᵖᵖ{Uint64,Uint32}
const schema::Entity* Char__CP__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Charᶜᵖᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// Charᶜᵖᶜᵖ:
// vulkan.Charᶜᵖᶜᵖ{Uint64,Uint32}
const schema::Entity* Char__CP__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Charᶜᵖᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageSubresourceLayers:
// vulkan.VkImageSubresourceLayers{Uint32,Uint32,Uint32,Uint32}
void VkImageSubresourceLayers::Encode(Encoder* e) const {
    e->Uint32(this->mAspectMask);
    e->Uint32(this->mMipLevel);
    e->Uint32(this->mBaseArrayLayer);
    e->Uint32(this->mLayerCount);
}
const schema::Entity* VkImageSubresourceLayers::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageSubresourceLayers",
        "",
        {
            schema::Field{"AspectMask", new schema::Primitive{"VkImageAspectFlags", schema::Primitive::Uint32}},
            schema::Field{"MipLevel", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"BaseArrayLayer", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"LayerCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkOffset3D:
// vulkan.VkOffset3D{Int32,Int32,Int32}
const schema::Entity* VkOffset3D::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkOffset3D",
        "",
        {
            schema::Field{"X", new schema::Primitive{"int32", schema::Primitive::Int32}},
            schema::Field{"Y", new schema::Primitive{"int32", schema::Primitive::Int32}},
            schema::Field{"Z", new schema::Primitive{"int32", schema::Primitive::Int32}},
        },
    };
    return &entity;
}

// VkExtent3D:
// vulkan.VkExtent3D{Uint32,Uint32,Uint32}
const schema::Entity* VkExtent3D::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkExtent3D",
        "",
        {
            schema::Field{"Width", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Height", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Depth", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBufferImageCopy:
// vulkan.VkBufferImageCopy{Uint64,Uint32,Uint32,$,$,$}
void VkBufferImageCopy::Encode(Encoder* e) const {
    e->Uint64(this->mBufferOffset);
    e->Uint32(this->mBufferRowLength);
    e->Uint32(this->mBufferImageHeight);
    e->Struct(this->mImageSubresource);
    e->Struct(this->mImageOffset);
    e->Struct(this->mImageExtent);
}
const schema::Entity* VkBufferImageCopy::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferImageCopy",
        "",
        {
            schema::Field{"BufferOffset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"BufferRowLength", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"BufferImageHeight", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"ImageSubresource", new schema::Struct{ VkImageSubresourceLayers::StaticSchema()}},
            schema::Field{"ImageOffset", new schema::Struct{ VkOffset3D::StaticSchema()}},
            schema::Field{"ImageExtent", new schema::Struct{ VkExtent3D::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageCopy:
// vulkan.VkImageCopy{$,$,$,$,$}
void VkImageCopy::Encode(Encoder* e) const {
    e->Struct(this->mSrcSubresource);
    e->Struct(this->mSrcOffset);
    e->Struct(this->mDstSubresource);
    e->Struct(this->mDstOffset);
    e->Struct(this->mExtent);
}
const schema::Entity* VkImageCopy::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageCopy",
        "",
        {
            schema::Field{"SrcSubresource", new schema::Struct{ VkImageSubresourceLayers::StaticSchema()}},
            schema::Field{"SrcOffset", new schema::Struct{ VkOffset3D::StaticSchema()}},
            schema::Field{"DstSubresource", new schema::Struct{ VkImageSubresourceLayers::StaticSchema()}},
            schema::Field{"DstOffset", new schema::Struct{ VkOffset3D::StaticSchema()}},
            schema::Field{"Extent", new schema::Struct{ VkExtent3D::StaticSchema()}},
        },
    };
    return &entity;
}

// Voidᶜᵖ:
// vulkan.Voidᶜᵖ{Uint64,Uint32}
const schema::Entity* Void__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Voidᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageSubresourceRange:
// vulkan.VkImageSubresourceRange{Uint32,Uint32,Uint32,Uint32,Uint32}
void VkImageSubresourceRange::Encode(Encoder* e) const {
    e->Uint32(this->mAspectMask);
    e->Uint32(this->mBaseMipLevel);
    e->Uint32(this->mLevelCount);
    e->Uint32(this->mBaseArrayLayer);
    e->Uint32(this->mLayerCount);
}
const schema::Entity* VkImageSubresourceRange::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageSubresourceRange",
        "",
        {
            schema::Field{"AspectMask", new schema::Primitive{"VkImageAspectFlags", schema::Primitive::Uint32}},
            schema::Field{"BaseMipLevel", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"LevelCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"BaseArrayLayer", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"LayerCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageMemoryBarrier:
// vulkan.VkImageMemoryBarrier{Uint32,$,Uint32,Uint32,Uint32,Uint32,Uint32,Uint32,Uint64,$}
void VkImageMemoryBarrier::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mSrcAccessMask);
    e->Uint32(this->mDstAccessMask);
    e->Uint32(this->mOldLayout);
    e->Uint32(this->mNewLayout);
    e->Uint32(this->mSrcQueueFamilyIndex);
    e->Uint32(this->mDstQueueFamilyIndex);
    e->Uint64(this->mImage);
    e->Struct(this->mSubresourceRange);
}
const schema::Entity* VkImageMemoryBarrier::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageMemoryBarrier",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"SrcAccessMask", new schema::Primitive{"VkAccessFlags", schema::Primitive::Uint32}},
            schema::Field{"DstAccessMask", new schema::Primitive{"VkAccessFlags", schema::Primitive::Uint32}},
            schema::Field{"OldLayout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
            schema::Field{"NewLayout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
            schema::Field{"SrcQueueFamilyIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"DstQueueFamilyIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Image", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"SubresourceRange", new schema::Struct{ VkImageSubresourceRange::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDescriptorBufferInfo:
// vulkan.VkDescriptorBufferInfo{Uint64,Uint64,Uint64}
const schema::Entity* VkDescriptorBufferInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorBufferInfo",
        "",
        {
            schema::Field{"Buffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"Offset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Range", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// Voidᵖ:
// vulkan.Voidᵖ{Uint64,Uint32}
const schema::Entity* Void__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Voidᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// U8ˢ:
// vulkan.U8ˢ{$}
const schema::Entity* U8__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "U8ˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

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

// Displayˢ:
// vulkan.Displayˢ{$}
const schema::Entity* Display__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Displayˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// Displayᵖ:
// vulkan.Displayᵖ{Uint64,Uint32}
const schema::Entity* Display__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Displayᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// F32ː2ᵃ:
// vulkan.F32ː2ᵃ{[2]Float32}
const schema::Entity* F32__2__A::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "F32ː2ᵃ",
        "",
        {
            schema::Field{"Elements", new schema::Array{"", new schema::Primitive{"float32", schema::Primitive::Float32}, 2}},
        },
    };
    return &entity;
}

// F32ː4ᵃ:
// vulkan.F32ː4ᵃ{[4]Float32}
const schema::Entity* F32__4__A::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "F32ː4ᵃ",
        "",
        {
            schema::Field{"Elements", new schema::Array{"", new schema::Primitive{"float32", schema::Primitive::Float32}, 4}},
        },
    };
    return &entity;
}

// F32ˢ:
// vulkan.F32ˢ{$}
const schema::Entity* F32__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "F32ˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// F32ᵖ:
// vulkan.F32ᵖ{Uint64,Uint32}
const schema::Entity* F32__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "F32ᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// F32ᶜᵖ:
// vulkan.F32ᶜᵖ{Uint64,Uint32}
const schema::Entity* F32__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "F32ᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// Intˢ:
// vulkan.Intˢ{$}
const schema::Entity* Int__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Intˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// Intᵖ:
// vulkan.Intᵖ{Uint64,Uint32}
const schema::Entity* Int__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Intᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// MirConnectionˢ:
// vulkan.MirConnectionˢ{$}
const schema::Entity* MirConnection__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "MirConnectionˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// MirConnectionᵖ:
// vulkan.MirConnectionᵖ{Uint64,Uint32}
const schema::Entity* MirConnection__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "MirConnectionᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// MirSurfaceˢ:
// vulkan.MirSurfaceˢ{$}
const schema::Entity* MirSurface__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "MirSurfaceˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// MirSurfaceᵖ:
// vulkan.MirSurfaceᵖ{Uint64,Uint32}
const schema::Entity* MirSurface__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "MirSurfaceᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// PFN_vkAllocationFunction:
// vulkan.PFN_vkAllocationFunction{Uint64,Uint32}
const schema::Entity* PFN_vkAllocationFunction::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "PFN_vkAllocationFunction",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// PFN_vkDebugReportCallbackEXT:
// vulkan.PFN_vkDebugReportCallbackEXT{Uint64,Uint32}
const schema::Entity* PFN_vkDebugReportCallbackEXT::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "PFN_vkDebugReportCallbackEXT",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// PFN_vkFreeFunction:
// vulkan.PFN_vkFreeFunction{Uint64,Uint32}
const schema::Entity* PFN_vkFreeFunction::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "PFN_vkFreeFunction",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// PFN_vkInternalAllocationNotification:
// vulkan.PFN_vkInternalAllocationNotification{Uint64,Uint32}
const schema::Entity* PFN_vkInternalAllocationNotification::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "PFN_vkInternalAllocationNotification",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// PFN_vkInternalFreeNotification:
// vulkan.PFN_vkInternalFreeNotification{Uint64,Uint32}
const schema::Entity* PFN_vkInternalFreeNotification::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "PFN_vkInternalFreeNotification",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// PFN_vkReallocationFunction:
// vulkan.PFN_vkReallocationFunction{Uint64,Uint32}
const schema::Entity* PFN_vkReallocationFunction::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "PFN_vkReallocationFunction",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// PFN_vkVoidFunction:
// vulkan.PFN_vkVoidFunction{Uint64,Uint32}
const schema::Entity* PFN_vkVoidFunction::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "PFN_vkVoidFunction",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMemoryType:
// vulkan.VkMemoryType{Uint32,Uint32}
const schema::Entity* VkMemoryType::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMemoryType",
        "",
        {
            schema::Field{"PropertyFlags", new schema::Primitive{"VkMemoryPropertyFlags", schema::Primitive::Uint32}},
            schema::Field{"HeapIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMemoryTypeː32ᵃ:
// vulkan.VkMemoryTypeː32ᵃ{[32]$}
const schema::Entity* VkMemoryType__32__A::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMemoryTypeː32ᵃ",
        "",
        {
            schema::Field{"Elements", new schema::Array{"", new schema::Struct{ VkMemoryType::StaticSchema()}, 32}},
        },
    };
    return &entity;
}

// VkMemoryHeap:
// vulkan.VkMemoryHeap{Uint64,Uint32}
const schema::Entity* VkMemoryHeap::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMemoryHeap",
        "",
        {
            schema::Field{"Size", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Flags", new schema::Primitive{"VkMemoryHeapFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMemoryHeapː16ᵃ:
// vulkan.VkMemoryHeapː16ᵃ{[16]$}
const schema::Entity* VkMemoryHeap__16__A::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMemoryHeapː16ᵃ",
        "",
        {
            schema::Field{"Elements", new schema::Array{"", new schema::Struct{ VkMemoryHeap::StaticSchema()}, 16}},
        },
    };
    return &entity;
}

// VkPhysicalDeviceMemoryProperties:
// vulkan.VkPhysicalDeviceMemoryProperties{Uint32,$,Uint32,$}
void VkPhysicalDeviceMemoryProperties::Encode(Encoder* e) const {
    e->Uint32(this->mMemoryTypeCount);
    e->Struct(this->mMemoryTypes);
    e->Uint32(this->mMemoryHeapCount);
    e->Struct(this->mMemoryHeaps);
}
const schema::Entity* VkPhysicalDeviceMemoryProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPhysicalDeviceMemoryProperties",
        "",
        {
            schema::Field{"MemoryTypeCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"MemoryTypes", new schema::Struct{ VkMemoryType__32__A::StaticSchema()}},
            schema::Field{"MemoryHeapCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"MemoryHeaps", new schema::Struct{ VkMemoryHeap__16__A::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDeviceCreateInfoᶜᵖ:
// vulkan.VkDeviceCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkDeviceCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDeviceCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkAllocationCallbacksᶜᵖ:
// vulkan.VkAllocationCallbacksᶜᵖ{Uint64,Uint32}
const schema::Entity* VkAllocationCallbacks__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAllocationCallbacksᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDeviceᵖ:
// vulkan.VkDeviceᵖ{Uint64,Uint32}
const schema::Entity* VkDevice__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDeviceᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// ReplayCreateVkDevice:
// vulkan.ReplayCreateVkDevice{[]?,Uint64,$,$,$,Uint32}
void ReplayCreateVkDevice::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPDevice);
    e->Uint32(this->mResult);
}
const schema::Entity* ReplayCreateVkDevice::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "ReplayCreateVkDevice",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkDeviceCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PDevice", new schema::Struct{ VkDevice__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkInstanceCreateInfoᶜᵖ:
// vulkan.VkInstanceCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkInstanceCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkInstanceCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkInstanceᵖ:
// vulkan.VkInstanceᵖ{Uint64,Uint32}
const schema::Entity* VkInstance__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkInstanceᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// ReplayCreateVkInstance:
// vulkan.ReplayCreateVkInstance{[]?,$,$,$,Uint32}
void ReplayCreateVkInstance::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPInstance);
    e->Uint32(this->mResult);
}
const schema::Entity* ReplayCreateVkInstance::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "ReplayCreateVkInstance",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkInstanceCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PInstance", new schema::Struct{ VkInstance__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCommandBufferᵖ:
// vulkan.VkCommandBufferᵖ{Uint64,Uint32}
const schema::Entity* VkCommandBuffer__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandBufferᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// ReplayRegisterVkCommandBuffers:
// vulkan.ReplayRegisterVkCommandBuffers{[]?,Uint64,Uint32,$}
void ReplayRegisterVkCommandBuffers::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint32(this->mCount);
    e->Struct(this->mCommandBuffers);
}
const schema::Entity* ReplayRegisterVkCommandBuffers::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "ReplayRegisterVkCommandBuffers",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Count", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"CommandBuffers", new schema::Struct{ VkCommandBuffer__P::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDeviceCreateInfoᵖ:
// vulkan.VkDeviceCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkDeviceCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDeviceCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// ReplayRegisterVkDevice:
// vulkan.ReplayRegisterVkDevice{[]?,Uint64,Uint64,$}
void ReplayRegisterVkDevice::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Uint64(this->mDevice);
    e->Struct(this->mCreateInfo);
}
const schema::Entity* ReplayRegisterVkDevice::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "ReplayRegisterVkDevice",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"CreateInfo", new schema::Struct{ VkDeviceCreateInfo__P::StaticSchema()}},
        },
    };
    return &entity;
}

// ReplayRegisterVkInstance:
// vulkan.ReplayRegisterVkInstance{[]?,Uint64}
const schema::Entity* ReplayRegisterVkInstance::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "ReplayRegisterVkInstance",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Instance", new schema::Primitive{"VkInstance", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// ReplayUnregisterVkCommandBuffers:
// vulkan.ReplayUnregisterVkCommandBuffers{[]?,Uint32,$}
const schema::Entity* ReplayUnregisterVkCommandBuffers::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "ReplayUnregisterVkCommandBuffers",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Count", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"CommandBuffers", new schema::Struct{ VkCommandBuffer__P::StaticSchema()}},
        },
    };
    return &entity;
}

// ReplayUnregisterVkDevice:
// vulkan.ReplayUnregisterVkDevice{[]?,Uint64}
const schema::Entity* ReplayUnregisterVkDevice::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "ReplayUnregisterVkDevice",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// ReplayUnregisterVkInstance:
// vulkan.ReplayUnregisterVkInstance{[]?,Uint64}
const schema::Entity* ReplayUnregisterVkInstance::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "ReplayUnregisterVkInstance",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Instance", new schema::Primitive{"VkInstance", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// U32ˢ:
// vulkan.U32ˢ{$}
const schema::Entity* U32__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "U32ˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// Sizeˢ:
// vulkan.Sizeˢ{$}
const schema::Entity* Size__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Sizeˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// Sizeᵖ:
// vulkan.Sizeᵖ{Uint64,Uint32}
const schema::Entity* Size__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Sizeᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSwapchainKHRᵖ:
// vulkan.VkSwapchainKHRᵖ{Uint64,Uint32}
const schema::Entity* VkSwapchainKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSwapchainKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// ToggleVirtualSwapchainReturnAcquiredImage:
// vulkan.ToggleVirtualSwapchainReturnAcquiredImage{[]?,$}
const schema::Entity* ToggleVirtualSwapchainReturnAcquiredImage::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "ToggleVirtualSwapchainReturnAcquiredImage",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PSwapchain", new schema::Struct{ VkSwapchainKHR__P::StaticSchema()}},
        },
    };
    return &entity;
}

// U32ː2ᵃ:
// vulkan.U32ː2ᵃ{[2]Uint32}
const schema::Entity* U32__2__A::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "U32ː2ᵃ",
        "",
        {
            schema::Field{"Elements", new schema::Array{"", new schema::Primitive{"uint32", schema::Primitive::Uint32}, 2}},
        },
    };
    return &entity;
}

// U32ː3ᵃ:
// vulkan.U32ː3ᵃ{[3]Uint32}
const schema::Entity* U32__3__A::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "U32ː3ᵃ",
        "",
        {
            schema::Field{"Elements", new schema::Array{"", new schema::Primitive{"uint32", schema::Primitive::Uint32}, 3}},
        },
    };
    return &entity;
}

// U32ː4ᵃ:
// vulkan.U32ː4ᵃ{[4]Uint32}
const schema::Entity* U32__4__A::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "U32ː4ᵃ",
        "",
        {
            schema::Field{"Elements", new schema::Array{"", new schema::Primitive{"uint32", schema::Primitive::Uint32}, 4}},
        },
    };
    return &entity;
}

// U32ᵖ:
// vulkan.U32ᵖ{Uint64,Uint32}
const schema::Entity* U32__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "U32ᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// U32ᶜᵖ:
// vulkan.U32ᶜᵖ{Uint64,Uint32}
const schema::Entity* U32__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "U32ᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// U8ː16ᵃ:
// vulkan.U8ː16ᵃ{[16]Uint8}
const schema::Entity* U8__16__A::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "U8ː16ᵃ",
        "",
        {
            schema::Field{"Elements", new schema::Array{"", new schema::Primitive{"uint8", schema::Primitive::Uint8}, 16}},
        },
    };
    return &entity;
}

// U8ᵖ:
// vulkan.U8ᵖ{Uint64,Uint32}
const schema::Entity* U8__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "U8ᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkAcquireImageANDROID:
// vulkan.VkAcquireImageANDROID{[]?,Uint64,Uint64,Int64,Uint64,Uint64,Uint32}
void VkAcquireImageANDROID::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mImage);
    e->Int64(this->mNativeFenceFd);
    e->Uint64(this->mSemaphore);
    e->Uint64(this->mFence);
    e->Uint32(this->mResult);
}
const schema::Entity* VkAcquireImageANDROID::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAcquireImageANDROID",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Image", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"NativeFenceFd", new schema::Primitive{"int64", schema::Primitive::Int64}},
            schema::Field{"Semaphore", new schema::Primitive{"VkSemaphore", schema::Primitive::Uint64}},
            schema::Field{"Fence", new schema::Primitive{"VkFence", schema::Primitive::Uint64}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkAcquireNextImageKHR:
// vulkan.VkAcquireNextImageKHR{[]?,Uint64,Uint64,Uint64,Uint64,Uint64,$,Uint32}
void VkAcquireNextImageKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mSwapchain);
    e->Uint64(this->mTimeout);
    e->Uint64(this->mSemaphore);
    e->Uint64(this->mFence);
    e->Struct(this->mPImageIndex);
    e->Uint32(this->mResult);
}
const schema::Entity* VkAcquireNextImageKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAcquireNextImageKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Swapchain", new schema::Primitive{"VkSwapchainKHR", schema::Primitive::Uint64}},
            schema::Field{"Timeout", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Semaphore", new schema::Primitive{"VkSemaphore", schema::Primitive::Uint64}},
            schema::Field{"Fence", new schema::Primitive{"VkFence", schema::Primitive::Uint64}},
            schema::Field{"PImageIndex", new schema::Struct{ U32__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCommandBufferAllocateInfoᶜᵖ:
// vulkan.VkCommandBufferAllocateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkCommandBufferAllocateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandBufferAllocateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkAllocateCommandBuffers:
// vulkan.VkAllocateCommandBuffers{[]?,Uint64,$,$,Uint32}
void VkAllocateCommandBuffers::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPAllocateInfo);
    e->Struct(this->mPCommandBuffers);
    e->Uint32(this->mResult);
}
const schema::Entity* VkAllocateCommandBuffers::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAllocateCommandBuffers",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PAllocateInfo", new schema::Struct{ VkCommandBufferAllocateInfo__CP::StaticSchema()}},
            schema::Field{"PCommandBuffers", new schema::Struct{ VkCommandBuffer__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorSetAllocateInfoᶜᵖ:
// vulkan.VkDescriptorSetAllocateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorSetAllocateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetAllocateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorSetᵖ:
// vulkan.VkDescriptorSetᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorSet__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkAllocateDescriptorSets:
// vulkan.VkAllocateDescriptorSets{[]?,Uint64,$,$,Uint32}
void VkAllocateDescriptorSets::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPAllocateInfo);
    e->Struct(this->mPDescriptorSets);
    e->Uint32(this->mResult);
}
const schema::Entity* VkAllocateDescriptorSets::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAllocateDescriptorSets",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PAllocateInfo", new schema::Struct{ VkDescriptorSetAllocateInfo__CP::StaticSchema()}},
            schema::Field{"PDescriptorSets", new schema::Struct{ VkDescriptorSet__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMemoryAllocateInfoᶜᵖ:
// vulkan.VkMemoryAllocateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkMemoryAllocateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMemoryAllocateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDeviceMemoryᵖ:
// vulkan.VkDeviceMemoryᵖ{Uint64,Uint32}
const schema::Entity* VkDeviceMemory__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDeviceMemoryᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkAllocateMemory:
// vulkan.VkAllocateMemory{[]?,Uint64,$,$,$,Uint32}
void VkAllocateMemory::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPAllocateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPMemory);
    e->Uint32(this->mResult);
}
const schema::Entity* VkAllocateMemory::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAllocateMemory",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PAllocateInfo", new schema::Struct{ VkMemoryAllocateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PMemory", new schema::Struct{ VkDeviceMemory__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkAllocationCallbacks:
// vulkan.VkAllocationCallbacks{$,$,$,$,$,$}
void VkAllocationCallbacks::Encode(Encoder* e) const {
    e->Struct(this->mPUserData);
    e->Struct(this->mPfnAllocation);
    e->Struct(this->mPfnReallocation);
    e->Struct(this->mPfnFree);
    e->Struct(this->mPfnInternalAllocation);
    e->Struct(this->mPfnInternalFree);
}
const schema::Entity* VkAllocationCallbacks::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAllocationCallbacks",
        "",
        {
            schema::Field{"PUserData", new schema::Struct{ Void__P::StaticSchema()}},
            schema::Field{"PfnAllocation", new schema::Struct{ PFN_vkAllocationFunction::StaticSchema()}},
            schema::Field{"PfnReallocation", new schema::Struct{ PFN_vkReallocationFunction::StaticSchema()}},
            schema::Field{"PfnFree", new schema::Struct{ PFN_vkFreeFunction::StaticSchema()}},
            schema::Field{"PfnInternalAllocation", new schema::Struct{ PFN_vkInternalAllocationNotification::StaticSchema()}},
            schema::Field{"PfnInternalFree", new schema::Struct{ PFN_vkInternalFreeNotification::StaticSchema()}},
        },
    };
    return &entity;
}

// VkAllocationCallbacksˢ:
// vulkan.VkAllocationCallbacksˢ{$}
const schema::Entity* VkAllocationCallbacks__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAllocationCallbacksˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkAllocationCallbacksᵖ:
// vulkan.VkAllocationCallbacksᵖ{Uint64,Uint32}
const schema::Entity* VkAllocationCallbacks__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAllocationCallbacksᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkAndroidSurfaceCreateInfoKHRˢ:
// vulkan.VkAndroidSurfaceCreateInfoKHRˢ{$}
const schema::Entity* VkAndroidSurfaceCreateInfoKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAndroidSurfaceCreateInfoKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkAndroidSurfaceCreateInfoKHRᵖ:
// vulkan.VkAndroidSurfaceCreateInfoKHRᵖ{Uint64,Uint32}
const schema::Entity* VkAndroidSurfaceCreateInfoKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAndroidSurfaceCreateInfoKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkAndroidSurfaceCreateInfoKHRᶜᵖ:
// vulkan.VkAndroidSurfaceCreateInfoKHRᶜᵖ{Uint64,Uint32}
const schema::Entity* VkAndroidSurfaceCreateInfoKHR__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAndroidSurfaceCreateInfoKHRᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkApplicationInfo:
// vulkan.VkApplicationInfo{Uint32,$,$,Uint32,$,Uint32,Uint32}
void VkApplicationInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Struct(this->mPApplicationName);
    e->Uint32(this->mApplicationVersion);
    e->Struct(this->mPEngineName);
    e->Uint32(this->mEngineVersion);
    e->Uint32(this->mApiVersion);
}
const schema::Entity* VkApplicationInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkApplicationInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"PApplicationName", new schema::Struct{ Char__CP::StaticSchema()}},
            schema::Field{"ApplicationVersion", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PEngineName", new schema::Struct{ Char__CP::StaticSchema()}},
            schema::Field{"EngineVersion", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"ApiVersion", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkApplicationInfoˢ:
// vulkan.VkApplicationInfoˢ{$}
const schema::Entity* VkApplicationInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkApplicationInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkApplicationInfoᵖ:
// vulkan.VkApplicationInfoᵖ{Uint64,Uint32}
const schema::Entity* VkApplicationInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkApplicationInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkApplicationInfoᶜᵖ:
// vulkan.VkApplicationInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkApplicationInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkApplicationInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkAttachmentDescription:
// vulkan.VkAttachmentDescription{Uint32,Uint32,Uint32,Uint32,Uint32,Uint32,Uint32,Uint32,Uint32}
void VkAttachmentDescription::Encode(Encoder* e) const {
    e->Uint32(this->mFlags);
    e->Uint32(this->mFormat);
    e->Uint32(this->mSamples);
    e->Uint32(this->mLoadOp);
    e->Uint32(this->mStoreOp);
    e->Uint32(this->mStencilLoadOp);
    e->Uint32(this->mStencilStoreOp);
    e->Uint32(this->mInitialLayout);
    e->Uint32(this->mFinalLayout);
}
const schema::Entity* VkAttachmentDescription::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAttachmentDescription",
        "",
        {
            schema::Field{"Flags", new schema::Primitive{"VkAttachmentDescriptionFlags", schema::Primitive::Uint32}},
            schema::Field{"Format", new schema::Primitive{"VkFormat", schema::Primitive::Uint32}},
            schema::Field{"Samples", new schema::Primitive{"VkSampleCountFlagBits", schema::Primitive::Uint32}},
            schema::Field{"LoadOp", new schema::Primitive{"VkAttachmentLoadOp", schema::Primitive::Uint32}},
            schema::Field{"StoreOp", new schema::Primitive{"VkAttachmentStoreOp", schema::Primitive::Uint32}},
            schema::Field{"StencilLoadOp", new schema::Primitive{"VkAttachmentLoadOp", schema::Primitive::Uint32}},
            schema::Field{"StencilStoreOp", new schema::Primitive{"VkAttachmentStoreOp", schema::Primitive::Uint32}},
            schema::Field{"InitialLayout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
            schema::Field{"FinalLayout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkAttachmentDescriptionˢ:
// vulkan.VkAttachmentDescriptionˢ{$}
const schema::Entity* VkAttachmentDescription__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAttachmentDescriptionˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkAttachmentDescriptionᵖ:
// vulkan.VkAttachmentDescriptionᵖ{Uint64,Uint32}
const schema::Entity* VkAttachmentDescription__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAttachmentDescriptionᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkAttachmentDescriptionᶜᵖ:
// vulkan.VkAttachmentDescriptionᶜᵖ{Uint64,Uint32}
const schema::Entity* VkAttachmentDescription__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAttachmentDescriptionᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkAttachmentReference:
// vulkan.VkAttachmentReference{Uint32,Uint32}
const schema::Entity* VkAttachmentReference::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAttachmentReference",
        "",
        {
            schema::Field{"Attachment", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Layout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkAttachmentReferenceˢ:
// vulkan.VkAttachmentReferenceˢ{$}
const schema::Entity* VkAttachmentReference__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAttachmentReferenceˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkAttachmentReferenceᵖ:
// vulkan.VkAttachmentReferenceᵖ{Uint64,Uint32}
const schema::Entity* VkAttachmentReference__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAttachmentReferenceᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkAttachmentReferenceᶜᵖ:
// vulkan.VkAttachmentReferenceᶜᵖ{Uint64,Uint32}
const schema::Entity* VkAttachmentReference__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkAttachmentReferenceᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCommandBufferBeginInfoᶜᵖ:
// vulkan.VkCommandBufferBeginInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkCommandBufferBeginInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandBufferBeginInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBeginCommandBuffer:
// vulkan.VkBeginCommandBuffer{[]?,Uint64,$,Uint32}
void VkBeginCommandBuffer::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Struct(this->mPBeginInfo);
    e->Uint32(this->mResult);
}
const schema::Entity* VkBeginCommandBuffer::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBeginCommandBuffer",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"PBeginInfo", new schema::Struct{ VkCommandBufferBeginInfo__CP::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBindBufferMemory:
// vulkan.VkBindBufferMemory{[]?,Uint64,Uint64,Uint64,Uint64,Uint32}
void VkBindBufferMemory::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mBuffer);
    e->Uint64(this->mMemory);
    e->Uint64(this->mMemoryOffset);
    e->Uint32(this->mResult);
}
const schema::Entity* VkBindBufferMemory::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBindBufferMemory",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Buffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"Memory", new schema::Primitive{"VkDeviceMemory", schema::Primitive::Uint64}},
            schema::Field{"MemoryOffset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBindImageMemory:
// vulkan.VkBindImageMemory{[]?,Uint64,Uint64,Uint64,Uint64,Uint32}
void VkBindImageMemory::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mImage);
    e->Uint64(this->mMemory);
    e->Uint64(this->mMemoryOffset);
    e->Uint32(this->mResult);
}
const schema::Entity* VkBindImageMemory::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBindImageMemory",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Image", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"Memory", new schema::Primitive{"VkDeviceMemory", schema::Primitive::Uint64}},
            schema::Field{"MemoryOffset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSemaphoreᶜᵖ:
// vulkan.VkSemaphoreᶜᵖ{Uint64,Uint32}
const schema::Entity* VkSemaphore__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSemaphoreᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSparseBufferMemoryBindInfoᶜᵖ:
// vulkan.VkSparseBufferMemoryBindInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkSparseBufferMemoryBindInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseBufferMemoryBindInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSparseImageOpaqueMemoryBindInfoᶜᵖ:
// vulkan.VkSparseImageOpaqueMemoryBindInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkSparseImageOpaqueMemoryBindInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseImageOpaqueMemoryBindInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSparseImageMemoryBindInfoᶜᵖ:
// vulkan.VkSparseImageMemoryBindInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkSparseImageMemoryBindInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseImageMemoryBindInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBindSparseInfo:
// vulkan.VkBindSparseInfo{Uint32,$,Uint32,$,Uint32,$,Uint32,$,Uint32,$,Uint32,$}
void VkBindSparseInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mWaitSemaphoreCount);
    e->Struct(this->mPWaitSemaphores);
    e->Uint32(this->mNumBufferBinds);
    e->Struct(this->mPBufferBinds);
    e->Uint32(this->mNumImageOpaqueBinds);
    e->Struct(this->mPImageOpaqueBinds);
    e->Uint32(this->mNumImageBinds);
    e->Struct(this->mPImageBinds);
    e->Uint32(this->mSignalSemaphoreCount);
    e->Struct(this->mPSignalSemaphores);
}
const schema::Entity* VkBindSparseInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBindSparseInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"WaitSemaphoreCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PWaitSemaphores", new schema::Struct{ VkSemaphore__CP::StaticSchema()}},
            schema::Field{"NumBufferBinds", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PBufferBinds", new schema::Struct{ VkSparseBufferMemoryBindInfo__CP::StaticSchema()}},
            schema::Field{"NumImageOpaqueBinds", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PImageOpaqueBinds", new schema::Struct{ VkSparseImageOpaqueMemoryBindInfo__CP::StaticSchema()}},
            schema::Field{"NumImageBinds", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PImageBinds", new schema::Struct{ VkSparseImageMemoryBindInfo__CP::StaticSchema()}},
            schema::Field{"SignalSemaphoreCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PSignalSemaphores", new schema::Struct{ VkSemaphore__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkBindSparseInfoˢ:
// vulkan.VkBindSparseInfoˢ{$}
const schema::Entity* VkBindSparseInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBindSparseInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkBindSparseInfoᵖ:
// vulkan.VkBindSparseInfoᵖ{Uint64,Uint32}
const schema::Entity* VkBindSparseInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBindSparseInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBindSparseInfoᶜᵖ:
// vulkan.VkBindSparseInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkBindSparseInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBindSparseInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBool32ˢ:
// vulkan.VkBool32ˢ{$}
const schema::Entity* VkBool32__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBool32ˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkBool32ᵖ:
// vulkan.VkBool32ᵖ{Uint64,Uint32}
const schema::Entity* VkBool32__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBool32ᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBufferCopy:
// vulkan.VkBufferCopy{Uint64,Uint64,Uint64}
const schema::Entity* VkBufferCopy::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferCopy",
        "",
        {
            schema::Field{"SrcOffset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"DstOffset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Size", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// VkBufferCopyˢ:
// vulkan.VkBufferCopyˢ{$}
const schema::Entity* VkBufferCopy__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferCopyˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkBufferCopyᵖ:
// vulkan.VkBufferCopyᵖ{Uint64,Uint32}
const schema::Entity* VkBufferCopy__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferCopyᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBufferCopyᶜᵖ:
// vulkan.VkBufferCopyᶜᵖ{Uint64,Uint32}
const schema::Entity* VkBufferCopy__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferCopyᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBufferCreateInfo:
// vulkan.VkBufferCreateInfo{Uint32,$,Uint32,Uint64,Uint32,Uint32,Uint32,$}
void VkBufferCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint64(this->mSize);
    e->Uint32(this->mUsage);
    e->Uint32(this->mSharingMode);
    e->Uint32(this->mQueueFamilyIndexCount);
    e->Struct(this->mPQueueFamilyIndices);
}
const schema::Entity* VkBufferCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkBufferCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"Size", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Usage", new schema::Primitive{"VkBufferUsageFlags", schema::Primitive::Uint32}},
            schema::Field{"SharingMode", new schema::Primitive{"VkSharingMode", schema::Primitive::Uint32}},
            schema::Field{"QueueFamilyIndexCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PQueueFamilyIndices", new schema::Struct{ U32__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkBufferCreateInfoˢ:
// vulkan.VkBufferCreateInfoˢ{$}
const schema::Entity* VkBufferCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkBufferCreateInfoᵖ:
// vulkan.VkBufferCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkBufferCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBufferCreateInfoᶜᵖ:
// vulkan.VkBufferCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkBufferCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBufferImageCopyˢ:
// vulkan.VkBufferImageCopyˢ{$}
const schema::Entity* VkBufferImageCopy__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferImageCopyˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkBufferImageCopyᵖ:
// vulkan.VkBufferImageCopyᵖ{Uint64,Uint32}
const schema::Entity* VkBufferImageCopy__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferImageCopyᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBufferImageCopyᶜᵖ:
// vulkan.VkBufferImageCopyᶜᵖ{Uint64,Uint32}
const schema::Entity* VkBufferImageCopy__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferImageCopyᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBufferMemoryBarrier:
// vulkan.VkBufferMemoryBarrier{Uint32,$,Uint32,Uint32,Uint32,Uint32,Uint64,Uint64,Uint64}
void VkBufferMemoryBarrier::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mSrcAccessMask);
    e->Uint32(this->mDstAccessMask);
    e->Uint32(this->mSrcQueueFamilyIndex);
    e->Uint32(this->mDstQueueFamilyIndex);
    e->Uint64(this->mBuffer);
    e->Uint64(this->mOffset);
    e->Uint64(this->mSize);
}
const schema::Entity* VkBufferMemoryBarrier::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferMemoryBarrier",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"SrcAccessMask", new schema::Primitive{"VkAccessFlags", schema::Primitive::Uint32}},
            schema::Field{"DstAccessMask", new schema::Primitive{"VkAccessFlags", schema::Primitive::Uint32}},
            schema::Field{"SrcQueueFamilyIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"DstQueueFamilyIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Buffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"Offset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Size", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// VkBufferMemoryBarrierˢ:
// vulkan.VkBufferMemoryBarrierˢ{$}
const schema::Entity* VkBufferMemoryBarrier__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferMemoryBarrierˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkBufferMemoryBarrierᵖ:
// vulkan.VkBufferMemoryBarrierᵖ{Uint64,Uint32}
const schema::Entity* VkBufferMemoryBarrier__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferMemoryBarrierᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBufferMemoryBarrierᶜᵖ:
// vulkan.VkBufferMemoryBarrierᶜᵖ{Uint64,Uint32}
const schema::Entity* VkBufferMemoryBarrier__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferMemoryBarrierᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBufferViewCreateInfo:
// vulkan.VkBufferViewCreateInfo{Uint32,$,Uint32,Uint64,Uint32,Uint64,Uint64}
void VkBufferViewCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint64(this->mBuffer);
    e->Uint32(this->mFormat);
    e->Uint64(this->mOffset);
    e->Uint64(this->mRange);
}
const schema::Entity* VkBufferViewCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferViewCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkBufferViewCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"Buffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"Format", new schema::Primitive{"VkFormat", schema::Primitive::Uint32}},
            schema::Field{"Offset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Range", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// VkBufferViewCreateInfoˢ:
// vulkan.VkBufferViewCreateInfoˢ{$}
const schema::Entity* VkBufferViewCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferViewCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkBufferViewCreateInfoᵖ:
// vulkan.VkBufferViewCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkBufferViewCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferViewCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBufferViewCreateInfoᶜᵖ:
// vulkan.VkBufferViewCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkBufferViewCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferViewCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBufferViewˢ:
// vulkan.VkBufferViewˢ{$}
const schema::Entity* VkBufferView__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferViewˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkBufferViewᵖ:
// vulkan.VkBufferViewᵖ{Uint64,Uint32}
const schema::Entity* VkBufferView__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferViewᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBufferViewᶜᵖ:
// vulkan.VkBufferViewᶜᵖ{Uint64,Uint32}
const schema::Entity* VkBufferView__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferViewᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBufferˢ:
// vulkan.VkBufferˢ{$}
const schema::Entity* VkBuffer__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkBufferᵖ:
// vulkan.VkBufferᵖ{Uint64,Uint32}
const schema::Entity* VkBuffer__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkBufferᶜᵖ:
// vulkan.VkBufferᶜᵖ{Uint64,Uint32}
const schema::Entity* VkBuffer__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkBufferᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkClearColorValue:
// vulkan.VkClearColorValue{$}
const schema::Entity* VkClearColorValue::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearColorValue",
        "",
        {
            schema::Field{"Uint32", new schema::Struct{ U32__4__A::StaticSchema()}},
        },
    };
    return &entity;
}

// VkClearValue:
// vulkan.VkClearValue{$}
const schema::Entity* VkClearValue::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearValue",
        "",
        {
            schema::Field{"Color", new schema::Struct{ VkClearColorValue::StaticSchema()}},
        },
    };
    return &entity;
}

// VkClearAttachment:
// vulkan.VkClearAttachment{Uint32,Uint32,$}
const schema::Entity* VkClearAttachment::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearAttachment",
        "",
        {
            schema::Field{"AspectMask", new schema::Primitive{"VkImageAspectFlags", schema::Primitive::Uint32}},
            schema::Field{"ColorAttachment", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"ClearValue", new schema::Struct{ VkClearValue::StaticSchema()}},
        },
    };
    return &entity;
}

// VkClearAttachmentˢ:
// vulkan.VkClearAttachmentˢ{$}
const schema::Entity* VkClearAttachment__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearAttachmentˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkClearAttachmentᵖ:
// vulkan.VkClearAttachmentᵖ{Uint64,Uint32}
const schema::Entity* VkClearAttachment__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearAttachmentᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkClearAttachmentᶜᵖ:
// vulkan.VkClearAttachmentᶜᵖ{Uint64,Uint32}
const schema::Entity* VkClearAttachment__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearAttachmentᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkClearColorValueˢ:
// vulkan.VkClearColorValueˢ{$}
const schema::Entity* VkClearColorValue__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearColorValueˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkClearColorValueᵖ:
// vulkan.VkClearColorValueᵖ{Uint64,Uint32}
const schema::Entity* VkClearColorValue__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearColorValueᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkClearColorValueᶜᵖ:
// vulkan.VkClearColorValueᶜᵖ{Uint64,Uint32}
const schema::Entity* VkClearColorValue__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearColorValueᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkClearDepthStencilValue:
// vulkan.VkClearDepthStencilValue{Float32,Uint32}
const schema::Entity* VkClearDepthStencilValue::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearDepthStencilValue",
        "",
        {
            schema::Field{"Depth", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"Stencil", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkClearDepthStencilValueˢ:
// vulkan.VkClearDepthStencilValueˢ{$}
const schema::Entity* VkClearDepthStencilValue__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearDepthStencilValueˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkClearDepthStencilValueᵖ:
// vulkan.VkClearDepthStencilValueᵖ{Uint64,Uint32}
const schema::Entity* VkClearDepthStencilValue__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearDepthStencilValueᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkClearDepthStencilValueᶜᵖ:
// vulkan.VkClearDepthStencilValueᶜᵖ{Uint64,Uint32}
const schema::Entity* VkClearDepthStencilValue__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearDepthStencilValueᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkOffset2D:
// vulkan.VkOffset2D{Int32,Int32}
const schema::Entity* VkOffset2D::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkOffset2D",
        "",
        {
            schema::Field{"X", new schema::Primitive{"int32", schema::Primitive::Int32}},
            schema::Field{"Y", new schema::Primitive{"int32", schema::Primitive::Int32}},
        },
    };
    return &entity;
}

// VkExtent2D:
// vulkan.VkExtent2D{Uint32,Uint32}
const schema::Entity* VkExtent2D::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkExtent2D",
        "",
        {
            schema::Field{"Width", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Height", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkRect2D:
// vulkan.VkRect2D{$,$}
const schema::Entity* VkRect2D::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkRect2D",
        "",
        {
            schema::Field{"Offset", new schema::Struct{ VkOffset2D::StaticSchema()}},
            schema::Field{"Extent", new schema::Struct{ VkExtent2D::StaticSchema()}},
        },
    };
    return &entity;
}

// VkClearRect:
// vulkan.VkClearRect{$,Uint32,Uint32}
const schema::Entity* VkClearRect::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearRect",
        "",
        {
            schema::Field{"Rect", new schema::Struct{ VkRect2D::StaticSchema()}},
            schema::Field{"BaseArrayLayer", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"LayerCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkClearRectˢ:
// vulkan.VkClearRectˢ{$}
const schema::Entity* VkClearRect__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearRectˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkClearRectᵖ:
// vulkan.VkClearRectᵖ{Uint64,Uint32}
const schema::Entity* VkClearRect__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearRectᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkClearRectᶜᵖ:
// vulkan.VkClearRectᶜᵖ{Uint64,Uint32}
const schema::Entity* VkClearRect__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearRectᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkClearValueˢ:
// vulkan.VkClearValueˢ{$}
const schema::Entity* VkClearValue__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearValueˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkClearValueᵖ:
// vulkan.VkClearValueᵖ{Uint64,Uint32}
const schema::Entity* VkClearValue__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearValueᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkClearValueᶜᵖ:
// vulkan.VkClearValueᶜᵖ{Uint64,Uint32}
const schema::Entity* VkClearValue__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkClearValueᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdBeginQuery:
// vulkan.VkCmdBeginQuery{[]?,Uint64,Uint64,Uint32,Uint32}
void VkCmdBeginQuery::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mQueryPool);
    e->Uint32(this->mQuery);
    e->Uint32(this->mFlags);
}
const schema::Entity* VkCmdBeginQuery::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdBeginQuery",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"QueryPool", new schema::Primitive{"VkQueryPool", schema::Primitive::Uint64}},
            schema::Field{"Query", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Flags", new schema::Primitive{"VkQueryControlFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkRenderPassBeginInfoᶜᵖ:
// vulkan.VkRenderPassBeginInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkRenderPassBeginInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkRenderPassBeginInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdBeginRenderPass:
// vulkan.VkCmdBeginRenderPass{[]?,Uint64,$,Uint32}
void VkCmdBeginRenderPass::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Struct(this->mPRenderPassBegin);
    e->Uint32(this->mContents);
}
const schema::Entity* VkCmdBeginRenderPass::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdBeginRenderPass",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"PRenderPassBegin", new schema::Struct{ VkRenderPassBeginInfo__CP::StaticSchema()}},
            schema::Field{"Contents", new schema::Primitive{"VkSubpassContents", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorSetᶜᵖ:
// vulkan.VkDescriptorSetᶜᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorSet__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdBindDescriptorSets:
// vulkan.VkCmdBindDescriptorSets{[]?,Uint64,Uint32,Uint64,Uint32,Uint32,$,Uint32,$}
void VkCmdBindDescriptorSets::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mPipelineBindPoint);
    e->Uint64(this->mLayout);
    e->Uint32(this->mFirstSet);
    e->Uint32(this->mDescriptorSetCount);
    e->Struct(this->mPDescriptorSets);
    e->Uint32(this->mDynamicOffsetCount);
    e->Struct(this->mPDynamicOffsets);
}
const schema::Entity* VkCmdBindDescriptorSets::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdBindDescriptorSets",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"PipelineBindPoint", new schema::Primitive{"VkPipelineBindPoint", schema::Primitive::Uint32}},
            schema::Field{"Layout", new schema::Primitive{"VkPipelineLayout", schema::Primitive::Uint64}},
            schema::Field{"FirstSet", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"DescriptorSetCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PDescriptorSets", new schema::Struct{ VkDescriptorSet__CP::StaticSchema()}},
            schema::Field{"DynamicOffsetCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PDynamicOffsets", new schema::Struct{ U32__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCmdBindIndexBuffer:
// vulkan.VkCmdBindIndexBuffer{[]?,Uint64,Uint64,Uint64,Uint32}
void VkCmdBindIndexBuffer::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mBuffer);
    e->Uint64(this->mOffset);
    e->Uint32(this->mIndexType);
}
const schema::Entity* VkCmdBindIndexBuffer::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdBindIndexBuffer",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"Buffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"Offset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"IndexType", new schema::Primitive{"VkIndexType", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdBindPipeline:
// vulkan.VkCmdBindPipeline{[]?,Uint64,Uint32,Uint64}
void VkCmdBindPipeline::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mPipelineBindPoint);
    e->Uint64(this->mPipeline);
}
const schema::Entity* VkCmdBindPipeline::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdBindPipeline",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"PipelineBindPoint", new schema::Primitive{"VkPipelineBindPoint", schema::Primitive::Uint32}},
            schema::Field{"Pipeline", new schema::Primitive{"VkPipeline", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// VkDeviceSizeᶜᵖ:
// vulkan.VkDeviceSizeᶜᵖ{Uint64,Uint32}
const schema::Entity* VkDeviceSize__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDeviceSizeᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdBindVertexBuffers:
// vulkan.VkCmdBindVertexBuffers{[]?,Uint64,Uint32,Uint32,$,$}
void VkCmdBindVertexBuffers::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mFirstBinding);
    e->Uint32(this->mBindingCount);
    e->Struct(this->mPBuffers);
    e->Struct(this->mPOffsets);
}
const schema::Entity* VkCmdBindVertexBuffers::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdBindVertexBuffers",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"FirstBinding", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"BindingCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PBuffers", new schema::Struct{ VkBuffer__CP::StaticSchema()}},
            schema::Field{"POffsets", new schema::Struct{ VkDeviceSize__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageBlitᶜᵖ:
// vulkan.VkImageBlitᶜᵖ{Uint64,Uint32}
const schema::Entity* VkImageBlit__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageBlitᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdBlitImage:
// vulkan.VkCmdBlitImage{[]?,Uint64,Uint64,Uint32,Uint64,Uint32,Uint32,$,Uint32}
void VkCmdBlitImage::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mSrcImage);
    e->Uint32(this->mSrcImageLayout);
    e->Uint64(this->mDstImage);
    e->Uint32(this->mDstImageLayout);
    e->Uint32(this->mRegionCount);
    e->Struct(this->mPRegions);
    e->Uint32(this->mFilter);
}
const schema::Entity* VkCmdBlitImage::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdBlitImage",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"SrcImage", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"SrcImageLayout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
            schema::Field{"DstImage", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"DstImageLayout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
            schema::Field{"RegionCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PRegions", new schema::Struct{ VkImageBlit__CP::StaticSchema()}},
            schema::Field{"Filter", new schema::Primitive{"VkFilter", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdClearAttachments:
// vulkan.VkCmdClearAttachments{[]?,Uint64,Uint32,$,Uint32,$}
void VkCmdClearAttachments::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mAttachmentCount);
    e->Struct(this->mPAttachments);
    e->Uint32(this->mRectCount);
    e->Struct(this->mPRects);
}
const schema::Entity* VkCmdClearAttachments::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdClearAttachments",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"AttachmentCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PAttachments", new schema::Struct{ VkClearAttachment__CP::StaticSchema()}},
            schema::Field{"RectCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PRects", new schema::Struct{ VkClearRect__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageSubresourceRangeᶜᵖ:
// vulkan.VkImageSubresourceRangeᶜᵖ{Uint64,Uint32}
const schema::Entity* VkImageSubresourceRange__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageSubresourceRangeᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdClearColorImage:
// vulkan.VkCmdClearColorImage{[]?,Uint64,Uint64,Uint32,$,Uint32,$}
void VkCmdClearColorImage::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mImage);
    e->Uint32(this->mImageLayout);
    e->Struct(this->mPColor);
    e->Uint32(this->mRangeCount);
    e->Struct(this->mPRanges);
}
const schema::Entity* VkCmdClearColorImage::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdClearColorImage",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"Image", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"ImageLayout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
            schema::Field{"PColor", new schema::Struct{ VkClearColorValue__CP::StaticSchema()}},
            schema::Field{"RangeCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PRanges", new schema::Struct{ VkImageSubresourceRange__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCmdClearDepthStencilImage:
// vulkan.VkCmdClearDepthStencilImage{[]?,Uint64,Uint64,Uint32,$,Uint32,$}
void VkCmdClearDepthStencilImage::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mImage);
    e->Uint32(this->mImageLayout);
    e->Struct(this->mPDepthStencil);
    e->Uint32(this->mRangeCount);
    e->Struct(this->mPRanges);
}
const schema::Entity* VkCmdClearDepthStencilImage::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdClearDepthStencilImage",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"Image", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"ImageLayout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
            schema::Field{"PDepthStencil", new schema::Struct{ VkClearDepthStencilValue__CP::StaticSchema()}},
            schema::Field{"RangeCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PRanges", new schema::Struct{ VkImageSubresourceRange__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCmdCopyBuffer:
// vulkan.VkCmdCopyBuffer{[]?,Uint64,Uint64,Uint64,Uint32,$}
void VkCmdCopyBuffer::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mSrcBuffer);
    e->Uint64(this->mDstBuffer);
    e->Uint32(this->mRegionCount);
    e->Struct(this->mPRegions);
}
const schema::Entity* VkCmdCopyBuffer::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdCopyBuffer",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"SrcBuffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"DstBuffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"RegionCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PRegions", new schema::Struct{ VkBufferCopy__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCmdCopyBufferToImage:
// vulkan.VkCmdCopyBufferToImage{[]?,Uint64,Uint64,Uint64,Uint32,Uint32,$}
void VkCmdCopyBufferToImage::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mSrcBuffer);
    e->Uint64(this->mDstImage);
    e->Uint32(this->mDstImageLayout);
    e->Uint32(this->mRegionCount);
    e->Struct(this->mPRegions);
}
const schema::Entity* VkCmdCopyBufferToImage::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdCopyBufferToImage",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"SrcBuffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"DstImage", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"DstImageLayout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
            schema::Field{"RegionCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PRegions", new schema::Struct{ VkBufferImageCopy__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageCopyᶜᵖ:
// vulkan.VkImageCopyᶜᵖ{Uint64,Uint32}
const schema::Entity* VkImageCopy__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageCopyᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdCopyImage:
// vulkan.VkCmdCopyImage{[]?,Uint64,Uint64,Uint32,Uint64,Uint32,Uint32,$}
void VkCmdCopyImage::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mSrcImage);
    e->Uint32(this->mSrcImageLayout);
    e->Uint64(this->mDstImage);
    e->Uint32(this->mDstImageLayout);
    e->Uint32(this->mRegionCount);
    e->Struct(this->mPRegions);
}
const schema::Entity* VkCmdCopyImage::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdCopyImage",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"SrcImage", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"SrcImageLayout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
            schema::Field{"DstImage", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"DstImageLayout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
            schema::Field{"RegionCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PRegions", new schema::Struct{ VkImageCopy__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCmdCopyImageToBuffer:
// vulkan.VkCmdCopyImageToBuffer{[]?,Uint64,Uint64,Uint32,Uint64,Uint32,$}
void VkCmdCopyImageToBuffer::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mSrcImage);
    e->Uint32(this->mSrcImageLayout);
    e->Uint64(this->mDstBuffer);
    e->Uint32(this->mRegionCount);
    e->Struct(this->mPRegions);
}
const schema::Entity* VkCmdCopyImageToBuffer::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdCopyImageToBuffer",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"SrcImage", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"SrcImageLayout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
            schema::Field{"DstBuffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"RegionCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PRegions", new schema::Struct{ VkBufferImageCopy__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCmdCopyQueryPoolResults:
// vulkan.VkCmdCopyQueryPoolResults{[]?,Uint64,Uint64,Uint32,Uint32,Uint64,Uint64,Uint64,Uint32}
void VkCmdCopyQueryPoolResults::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mQueryPool);
    e->Uint32(this->mFirstQuery);
    e->Uint32(this->mQueryCount);
    e->Uint64(this->mDstBuffer);
    e->Uint64(this->mDstOffset);
    e->Uint64(this->mStride);
    e->Uint32(this->mFlags);
}
const schema::Entity* VkCmdCopyQueryPoolResults::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdCopyQueryPoolResults",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"QueryPool", new schema::Primitive{"VkQueryPool", schema::Primitive::Uint64}},
            schema::Field{"FirstQuery", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"QueryCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"DstBuffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"DstOffset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Stride", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Flags", new schema::Primitive{"VkQueryResultFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdDispatch:
// vulkan.VkCmdDispatch{[]?,Uint64,Uint32,Uint32,Uint32}
void VkCmdDispatch::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mX);
    e->Uint32(this->mY);
    e->Uint32(this->mZ);
}
const schema::Entity* VkCmdDispatch::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdDispatch",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"X", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Y", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Z", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdDispatchIndirect:
// vulkan.VkCmdDispatchIndirect{[]?,Uint64,Uint64,Uint64}
void VkCmdDispatchIndirect::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mBuffer);
    e->Uint64(this->mOffset);
}
const schema::Entity* VkCmdDispatchIndirect::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdDispatchIndirect",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"Buffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"Offset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// VkCmdDraw:
// vulkan.VkCmdDraw{[]?,Uint64,Uint32,Uint32,Uint32,Uint32}
void VkCmdDraw::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mVertexCount);
    e->Uint32(this->mInstanceCount);
    e->Uint32(this->mFirstVertex);
    e->Uint32(this->mFirstInstance);
}
const schema::Entity* VkCmdDraw::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdDraw",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"VertexCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"InstanceCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"FirstVertex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"FirstInstance", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdDrawIndexed:
// vulkan.VkCmdDrawIndexed{[]?,Uint64,Uint32,Uint32,Uint32,Int32,Uint32}
void VkCmdDrawIndexed::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mIndexCount);
    e->Uint32(this->mInstanceCount);
    e->Uint32(this->mFirstIndex);
    e->Int32(this->mVertexOffset);
    e->Uint32(this->mFirstInstance);
}
const schema::Entity* VkCmdDrawIndexed::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdDrawIndexed",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"IndexCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"InstanceCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"FirstIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"VertexOffset", new schema::Primitive{"int32", schema::Primitive::Int32}},
            schema::Field{"FirstInstance", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdDrawIndexedIndirect:
// vulkan.VkCmdDrawIndexedIndirect{[]?,Uint64,Uint64,Uint64,Uint32,Uint32}
void VkCmdDrawIndexedIndirect::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mBuffer);
    e->Uint64(this->mOffset);
    e->Uint32(this->mDrawCount);
    e->Uint32(this->mStride);
}
const schema::Entity* VkCmdDrawIndexedIndirect::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdDrawIndexedIndirect",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"Buffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"Offset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"DrawCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Stride", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdDrawIndirect:
// vulkan.VkCmdDrawIndirect{[]?,Uint64,Uint64,Uint64,Uint32,Uint32}
void VkCmdDrawIndirect::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mBuffer);
    e->Uint64(this->mOffset);
    e->Uint32(this->mDrawCount);
    e->Uint32(this->mStride);
}
const schema::Entity* VkCmdDrawIndirect::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdDrawIndirect",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"Buffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"Offset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"DrawCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Stride", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdEndQuery:
// vulkan.VkCmdEndQuery{[]?,Uint64,Uint64,Uint32}
void VkCmdEndQuery::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mQueryPool);
    e->Uint32(this->mQuery);
}
const schema::Entity* VkCmdEndQuery::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdEndQuery",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"QueryPool", new schema::Primitive{"VkQueryPool", schema::Primitive::Uint64}},
            schema::Field{"Query", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdEndRenderPass:
// vulkan.VkCmdEndRenderPass{[]?,Uint64}
const schema::Entity* VkCmdEndRenderPass::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdEndRenderPass",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// VkCommandBufferᶜᵖ:
// vulkan.VkCommandBufferᶜᵖ{Uint64,Uint32}
const schema::Entity* VkCommandBuffer__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandBufferᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdExecuteCommands:
// vulkan.VkCmdExecuteCommands{[]?,Uint64,Uint32,$}
void VkCmdExecuteCommands::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mCommandBufferCount);
    e->Struct(this->mPCommandBuffers);
}
const schema::Entity* VkCmdExecuteCommands::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdExecuteCommands",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"CommandBufferCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PCommandBuffers", new schema::Struct{ VkCommandBuffer__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCmdFillBuffer:
// vulkan.VkCmdFillBuffer{[]?,Uint64,Uint64,Uint64,Uint64,Uint32}
void VkCmdFillBuffer::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mDstBuffer);
    e->Uint64(this->mDstOffset);
    e->Uint64(this->mSize);
    e->Uint32(this->mData);
}
const schema::Entity* VkCmdFillBuffer::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdFillBuffer",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"DstBuffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"DstOffset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Size", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Data", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdNextSubpass:
// vulkan.VkCmdNextSubpass{[]?,Uint64,Uint32}
const schema::Entity* VkCmdNextSubpass::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdNextSubpass",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"Contents", new schema::Primitive{"VkSubpassContents", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMemoryBarrierᶜᵖ:
// vulkan.VkMemoryBarrierᶜᵖ{Uint64,Uint32}
const schema::Entity* VkMemoryBarrier__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMemoryBarrierᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageMemoryBarrierᶜᵖ:
// vulkan.VkImageMemoryBarrierᶜᵖ{Uint64,Uint32}
const schema::Entity* VkImageMemoryBarrier__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageMemoryBarrierᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdPipelineBarrier:
// vulkan.VkCmdPipelineBarrier{[]?,Uint64,Uint32,Uint32,Uint32,Uint32,$,Uint32,$,Uint32,$}
void VkCmdPipelineBarrier::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mSrcStageMask);
    e->Uint32(this->mDstStageMask);
    e->Uint32(this->mDependencyFlags);
    e->Uint32(this->mMemoryBarrierCount);
    e->Struct(this->mPMemoryBarriers);
    e->Uint32(this->mBufferMemoryBarrierCount);
    e->Struct(this->mPBufferMemoryBarriers);
    e->Uint32(this->mImageMemoryBarrierCount);
    e->Struct(this->mPImageMemoryBarriers);
}
const schema::Entity* VkCmdPipelineBarrier::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdPipelineBarrier",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"SrcStageMask", new schema::Primitive{"VkPipelineStageFlags", schema::Primitive::Uint32}},
            schema::Field{"DstStageMask", new schema::Primitive{"VkPipelineStageFlags", schema::Primitive::Uint32}},
            schema::Field{"DependencyFlags", new schema::Primitive{"VkDependencyFlags", schema::Primitive::Uint32}},
            schema::Field{"MemoryBarrierCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PMemoryBarriers", new schema::Struct{ VkMemoryBarrier__CP::StaticSchema()}},
            schema::Field{"BufferMemoryBarrierCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PBufferMemoryBarriers", new schema::Struct{ VkBufferMemoryBarrier__CP::StaticSchema()}},
            schema::Field{"ImageMemoryBarrierCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PImageMemoryBarriers", new schema::Struct{ VkImageMemoryBarrier__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCmdPushConstants:
// vulkan.VkCmdPushConstants{[]?,Uint64,Uint64,Uint32,Uint32,Uint32,$}
void VkCmdPushConstants::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mLayout);
    e->Uint32(this->mStageFlags);
    e->Uint32(this->mOffset);
    e->Uint32(this->mSize);
    e->Struct(this->mPValues);
}
const schema::Entity* VkCmdPushConstants::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdPushConstants",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"Layout", new schema::Primitive{"VkPipelineLayout", schema::Primitive::Uint64}},
            schema::Field{"StageFlags", new schema::Primitive{"VkShaderStageFlags", schema::Primitive::Uint32}},
            schema::Field{"Offset", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Size", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PValues", new schema::Struct{ Void__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCmdResetEvent:
// vulkan.VkCmdResetEvent{[]?,Uint64,Uint64,Uint32}
void VkCmdResetEvent::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mEvent);
    e->Uint32(this->mStageMask);
}
const schema::Entity* VkCmdResetEvent::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdResetEvent",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"Event", new schema::Primitive{"VkEvent", schema::Primitive::Uint64}},
            schema::Field{"StageMask", new schema::Primitive{"VkPipelineStageFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdResetQueryPool:
// vulkan.VkCmdResetQueryPool{[]?,Uint64,Uint64,Uint32,Uint32}
void VkCmdResetQueryPool::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mQueryPool);
    e->Uint32(this->mFirstQuery);
    e->Uint32(this->mQueryCount);
}
const schema::Entity* VkCmdResetQueryPool::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdResetQueryPool",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"QueryPool", new schema::Primitive{"VkQueryPool", schema::Primitive::Uint64}},
            schema::Field{"FirstQuery", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"QueryCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageResolveᶜᵖ:
// vulkan.VkImageResolveᶜᵖ{Uint64,Uint32}
const schema::Entity* VkImageResolve__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageResolveᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdResolveImage:
// vulkan.VkCmdResolveImage{[]?,Uint64,Uint64,Uint32,Uint64,Uint32,Uint32,$}
void VkCmdResolveImage::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mSrcImage);
    e->Uint32(this->mSrcImageLayout);
    e->Uint64(this->mDstImage);
    e->Uint32(this->mDstImageLayout);
    e->Uint32(this->mRegionCount);
    e->Struct(this->mPRegions);
}
const schema::Entity* VkCmdResolveImage::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdResolveImage",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"SrcImage", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"SrcImageLayout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
            schema::Field{"DstImage", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"DstImageLayout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
            schema::Field{"RegionCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PRegions", new schema::Struct{ VkImageResolve__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCmdSetBlendConstants:
// vulkan.VkCmdSetBlendConstants{[]?,Uint64,$}
const schema::Entity* VkCmdSetBlendConstants::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdSetBlendConstants",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"BlendConstants", new schema::Struct{ F32__4__A::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCmdSetDepthBias:
// vulkan.VkCmdSetDepthBias{[]?,Uint64,Float32,Float32,Float32}
void VkCmdSetDepthBias::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Float32(this->mDepthBiasConstantFactor);
    e->Float32(this->mDepthBiasClamp);
    e->Float32(this->mDepthBiasSlopeFactor);
}
const schema::Entity* VkCmdSetDepthBias::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdSetDepthBias",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"DepthBiasConstantFactor", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"DepthBiasClamp", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"DepthBiasSlopeFactor", new schema::Primitive{"float32", schema::Primitive::Float32}},
        },
    };
    return &entity;
}

// VkCmdSetDepthBounds:
// vulkan.VkCmdSetDepthBounds{[]?,Uint64,Float32,Float32}
void VkCmdSetDepthBounds::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Float32(this->mMinDepthBounds);
    e->Float32(this->mMaxDepthBounds);
}
const schema::Entity* VkCmdSetDepthBounds::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdSetDepthBounds",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"MinDepthBounds", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"MaxDepthBounds", new schema::Primitive{"float32", schema::Primitive::Float32}},
        },
    };
    return &entity;
}

// VkCmdSetEvent:
// vulkan.VkCmdSetEvent{[]?,Uint64,Uint64,Uint32}
void VkCmdSetEvent::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mEvent);
    e->Uint32(this->mStageMask);
}
const schema::Entity* VkCmdSetEvent::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdSetEvent",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"Event", new schema::Primitive{"VkEvent", schema::Primitive::Uint64}},
            schema::Field{"StageMask", new schema::Primitive{"VkPipelineStageFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdSetLineWidth:
// vulkan.VkCmdSetLineWidth{[]?,Uint64,Float32}
const schema::Entity* VkCmdSetLineWidth::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdSetLineWidth",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"LineWidth", new schema::Primitive{"float32", schema::Primitive::Float32}},
        },
    };
    return &entity;
}

// VkRect2Dᶜᵖ:
// vulkan.VkRect2Dᶜᵖ{Uint64,Uint32}
const schema::Entity* VkRect2D__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkRect2Dᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdSetScissor:
// vulkan.VkCmdSetScissor{[]?,Uint64,Uint32,Uint32,$}
void VkCmdSetScissor::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mFirstScissor);
    e->Uint32(this->mScissorCount);
    e->Struct(this->mPScissors);
}
const schema::Entity* VkCmdSetScissor::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdSetScissor",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"FirstScissor", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"ScissorCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PScissors", new schema::Struct{ VkRect2D__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCmdSetStencilCompareMask:
// vulkan.VkCmdSetStencilCompareMask{[]?,Uint64,Uint32,Uint32}
void VkCmdSetStencilCompareMask::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mFaceMask);
    e->Uint32(this->mCompareMask);
}
const schema::Entity* VkCmdSetStencilCompareMask::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdSetStencilCompareMask",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"FaceMask", new schema::Primitive{"VkStencilFaceFlags", schema::Primitive::Uint32}},
            schema::Field{"CompareMask", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdSetStencilReference:
// vulkan.VkCmdSetStencilReference{[]?,Uint64,Uint32,Uint32}
void VkCmdSetStencilReference::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mFaceMask);
    e->Uint32(this->mReference);
}
const schema::Entity* VkCmdSetStencilReference::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdSetStencilReference",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"FaceMask", new schema::Primitive{"VkStencilFaceFlags", schema::Primitive::Uint32}},
            schema::Field{"Reference", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdSetStencilWriteMask:
// vulkan.VkCmdSetStencilWriteMask{[]?,Uint64,Uint32,Uint32}
void VkCmdSetStencilWriteMask::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mFaceMask);
    e->Uint32(this->mWriteMask);
}
const schema::Entity* VkCmdSetStencilWriteMask::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdSetStencilWriteMask",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"FaceMask", new schema::Primitive{"VkStencilFaceFlags", schema::Primitive::Uint32}},
            schema::Field{"WriteMask", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkViewportᶜᵖ:
// vulkan.VkViewportᶜᵖ{Uint64,Uint32}
const schema::Entity* VkViewport__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkViewportᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdSetViewport:
// vulkan.VkCmdSetViewport{[]?,Uint64,Uint32,Uint32,$}
void VkCmdSetViewport::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mFirstViewport);
    e->Uint32(this->mViewportCount);
    e->Struct(this->mPViewports);
}
const schema::Entity* VkCmdSetViewport::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdSetViewport",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"FirstViewport", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"ViewportCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PViewports", new schema::Struct{ VkViewport__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCmdUpdateBuffer:
// vulkan.VkCmdUpdateBuffer{[]?,Uint64,Uint64,Uint64,Uint64,$}
void VkCmdUpdateBuffer::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint64(this->mDstBuffer);
    e->Uint64(this->mDstOffset);
    e->Uint64(this->mDataSize);
    e->Struct(this->mPData);
}
const schema::Entity* VkCmdUpdateBuffer::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdUpdateBuffer",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"DstBuffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"DstOffset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"DataSize", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"PData", new schema::Struct{ U32__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkEventᶜᵖ:
// vulkan.VkEventᶜᵖ{Uint64,Uint32}
const schema::Entity* VkEvent__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkEventᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCmdWaitEvents:
// vulkan.VkCmdWaitEvents{[]?,Uint64,Uint32,$,Uint32,Uint32,Uint32,$,Uint32,$,Uint32,$}
void VkCmdWaitEvents::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mEventCount);
    e->Struct(this->mPEvents);
    e->Uint32(this->mSrcStageMask);
    e->Uint32(this->mDstStageMask);
    e->Uint32(this->mMemoryBarrierCount);
    e->Struct(this->mPMemoryBarriers);
    e->Uint32(this->mBufferMemoryBarrierCount);
    e->Struct(this->mPBufferMemoryBarriers);
    e->Uint32(this->mImageMemoryBarrierCount);
    e->Struct(this->mPImageMemoryBarriers);
}
const schema::Entity* VkCmdWaitEvents::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdWaitEvents",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"EventCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PEvents", new schema::Struct{ VkEvent__CP::StaticSchema()}},
            schema::Field{"SrcStageMask", new schema::Primitive{"VkPipelineStageFlags", schema::Primitive::Uint32}},
            schema::Field{"DstStageMask", new schema::Primitive{"VkPipelineStageFlags", schema::Primitive::Uint32}},
            schema::Field{"MemoryBarrierCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PMemoryBarriers", new schema::Struct{ VkMemoryBarrier__CP::StaticSchema()}},
            schema::Field{"BufferMemoryBarrierCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PBufferMemoryBarriers", new schema::Struct{ VkBufferMemoryBarrier__CP::StaticSchema()}},
            schema::Field{"ImageMemoryBarrierCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PImageMemoryBarriers", new schema::Struct{ VkImageMemoryBarrier__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCmdWriteTimestamp:
// vulkan.VkCmdWriteTimestamp{[]?,Uint64,Uint32,Uint64,Uint32}
void VkCmdWriteTimestamp::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mPipelineStage);
    e->Uint64(this->mQueryPool);
    e->Uint32(this->mQuery);
}
const schema::Entity* VkCmdWriteTimestamp::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCmdWriteTimestamp",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"PipelineStage", new schema::Primitive{"VkPipelineStageFlagBits", schema::Primitive::Uint32}},
            schema::Field{"QueryPool", new schema::Primitive{"VkQueryPool", schema::Primitive::Uint64}},
            schema::Field{"Query", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCommandBufferAllocateInfo:
// vulkan.VkCommandBufferAllocateInfo{Uint32,$,Uint64,Uint32,Uint32}
void VkCommandBufferAllocateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint64(this->mCommandPool);
    e->Uint32(this->mLevel);
    e->Uint32(this->mCommandBufferCount);
}
const schema::Entity* VkCommandBufferAllocateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandBufferAllocateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"CommandPool", new schema::Primitive{"VkCommandPool", schema::Primitive::Uint64}},
            schema::Field{"Level", new schema::Primitive{"VkCommandBufferLevel", schema::Primitive::Uint32}},
            schema::Field{"CommandBufferCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCommandBufferAllocateInfoˢ:
// vulkan.VkCommandBufferAllocateInfoˢ{$}
const schema::Entity* VkCommandBufferAllocateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandBufferAllocateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCommandBufferAllocateInfoᵖ:
// vulkan.VkCommandBufferAllocateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkCommandBufferAllocateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandBufferAllocateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCommandBufferInheritanceInfoᶜᵖ:
// vulkan.VkCommandBufferInheritanceInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkCommandBufferInheritanceInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandBufferInheritanceInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCommandBufferBeginInfo:
// vulkan.VkCommandBufferBeginInfo{Uint32,$,Uint32,$}
void VkCommandBufferBeginInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Struct(this->mPInheritanceInfo);
}
const schema::Entity* VkCommandBufferBeginInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandBufferBeginInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkCommandBufferUsageFlags", schema::Primitive::Uint32}},
            schema::Field{"PInheritanceInfo", new schema::Struct{ VkCommandBufferInheritanceInfo__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCommandBufferBeginInfoˢ:
// vulkan.VkCommandBufferBeginInfoˢ{$}
const schema::Entity* VkCommandBufferBeginInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandBufferBeginInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCommandBufferBeginInfoᵖ:
// vulkan.VkCommandBufferBeginInfoᵖ{Uint64,Uint32}
const schema::Entity* VkCommandBufferBeginInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandBufferBeginInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCommandBufferInheritanceInfo:
// vulkan.VkCommandBufferInheritanceInfo{Uint32,$,Uint64,Uint32,Uint64,Uint32,Uint32,Uint32}
void VkCommandBufferInheritanceInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint64(this->mRenderPass);
    e->Uint32(this->mSubpass);
    e->Uint64(this->mFramebuffer);
    e->Uint32(this->mOcclusionQueryEnable);
    e->Uint32(this->mQueryFlags);
    e->Uint32(this->mPipelineStatistics);
}
const schema::Entity* VkCommandBufferInheritanceInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandBufferInheritanceInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"RenderPass", new schema::Primitive{"VkRenderPass", schema::Primitive::Uint64}},
            schema::Field{"Subpass", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Framebuffer", new schema::Primitive{"VkFramebuffer", schema::Primitive::Uint64}},
            schema::Field{"OcclusionQueryEnable", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"QueryFlags", new schema::Primitive{"VkQueryControlFlags", schema::Primitive::Uint32}},
            schema::Field{"PipelineStatistics", new schema::Primitive{"VkQueryPipelineStatisticFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCommandBufferInheritanceInfoˢ:
// vulkan.VkCommandBufferInheritanceInfoˢ{$}
const schema::Entity* VkCommandBufferInheritanceInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandBufferInheritanceInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCommandBufferInheritanceInfoᵖ:
// vulkan.VkCommandBufferInheritanceInfoᵖ{Uint64,Uint32}
const schema::Entity* VkCommandBufferInheritanceInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandBufferInheritanceInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCommandBufferˢ:
// vulkan.VkCommandBufferˢ{$}
const schema::Entity* VkCommandBuffer__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandBufferˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCommandPoolCreateInfo:
// vulkan.VkCommandPoolCreateInfo{Uint32,$,Uint32,Uint32}
void VkCommandPoolCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mQueueFamilyIndex);
}
const schema::Entity* VkCommandPoolCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandPoolCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkCommandPoolCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"QueueFamilyIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCommandPoolCreateInfoˢ:
// vulkan.VkCommandPoolCreateInfoˢ{$}
const schema::Entity* VkCommandPoolCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandPoolCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCommandPoolCreateInfoᵖ:
// vulkan.VkCommandPoolCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkCommandPoolCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandPoolCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCommandPoolCreateInfoᶜᵖ:
// vulkan.VkCommandPoolCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkCommandPoolCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandPoolCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCommandPoolˢ:
// vulkan.VkCommandPoolˢ{$}
const schema::Entity* VkCommandPool__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandPoolˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCommandPoolᵖ:
// vulkan.VkCommandPoolᵖ{Uint64,Uint32}
const schema::Entity* VkCommandPool__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCommandPoolᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkComponentMapping:
// vulkan.VkComponentMapping{Uint32,Uint32,Uint32,Uint32}
void VkComponentMapping::Encode(Encoder* e) const {
    e->Uint32(this->mR);
    e->Uint32(this->mG);
    e->Uint32(this->mB);
    e->Uint32(this->mA);
}
const schema::Entity* VkComponentMapping::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkComponentMapping",
        "",
        {
            schema::Field{"R", new schema::Primitive{"VkComponentSwizzle", schema::Primitive::Uint32}},
            schema::Field{"G", new schema::Primitive{"VkComponentSwizzle", schema::Primitive::Uint32}},
            schema::Field{"B", new schema::Primitive{"VkComponentSwizzle", schema::Primitive::Uint32}},
            schema::Field{"A", new schema::Primitive{"VkComponentSwizzle", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSpecializationInfoᶜᵖ:
// vulkan.VkSpecializationInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkSpecializationInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSpecializationInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineShaderStageCreateInfo:
// vulkan.VkPipelineShaderStageCreateInfo{Uint32,$,Uint32,Uint32,Uint64,$,$}
void VkPipelineShaderStageCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mStage);
    e->Uint64(this->mModule);
    e->Struct(this->mPName);
    e->Struct(this->mPSpecializationInfo);
}
const schema::Entity* VkPipelineShaderStageCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineShaderStageCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkPipelineShaderStageCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"Stage", new schema::Primitive{"VkShaderStageFlagBits", schema::Primitive::Uint32}},
            schema::Field{"Module", new schema::Primitive{"VkShaderModule", schema::Primitive::Uint64}},
            schema::Field{"PName", new schema::Struct{ Char__CP::StaticSchema()}},
            schema::Field{"PSpecializationInfo", new schema::Struct{ VkSpecializationInfo__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkComputePipelineCreateInfo:
// vulkan.VkComputePipelineCreateInfo{Uint32,$,Uint32,$,Uint64,Uint64,Int32}
void VkComputePipelineCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Struct(this->mStage);
    e->Uint64(this->mLayout);
    e->Uint64(this->mBasePipelineHandle);
    e->Int32(this->mBasePipelineIndex);
}
const schema::Entity* VkComputePipelineCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkComputePipelineCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkPipelineCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"Stage", new schema::Struct{ VkPipelineShaderStageCreateInfo::StaticSchema()}},
            schema::Field{"Layout", new schema::Primitive{"VkPipelineLayout", schema::Primitive::Uint64}},
            schema::Field{"BasePipelineHandle", new schema::Primitive{"VkPipeline", schema::Primitive::Uint64}},
            schema::Field{"BasePipelineIndex", new schema::Primitive{"int32", schema::Primitive::Int32}},
        },
    };
    return &entity;
}

// VkComputePipelineCreateInfoˢ:
// vulkan.VkComputePipelineCreateInfoˢ{$}
const schema::Entity* VkComputePipelineCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkComputePipelineCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkComputePipelineCreateInfoᵖ:
// vulkan.VkComputePipelineCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkComputePipelineCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkComputePipelineCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkComputePipelineCreateInfoᶜᵖ:
// vulkan.VkComputePipelineCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkComputePipelineCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkComputePipelineCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCopyDescriptorSet:
// vulkan.VkCopyDescriptorSet{Uint32,$,Uint64,Uint32,Uint32,Uint64,Uint32,Uint32,Uint32}
void VkCopyDescriptorSet::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint64(this->mSrcSet);
    e->Uint32(this->mSrcBinding);
    e->Uint32(this->mSrcArrayElement);
    e->Uint64(this->mDstSet);
    e->Uint32(this->mDstBinding);
    e->Uint32(this->mDstArrayElement);
    e->Uint32(this->mDescriptorCount);
}
const schema::Entity* VkCopyDescriptorSet::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCopyDescriptorSet",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"SrcSet", new schema::Primitive{"VkDescriptorSet", schema::Primitive::Uint64}},
            schema::Field{"SrcBinding", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"SrcArrayElement", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"DstSet", new schema::Primitive{"VkDescriptorSet", schema::Primitive::Uint64}},
            schema::Field{"DstBinding", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"DstArrayElement", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"DescriptorCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCopyDescriptorSetˢ:
// vulkan.VkCopyDescriptorSetˢ{$}
const schema::Entity* VkCopyDescriptorSet__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCopyDescriptorSetˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkCopyDescriptorSetᵖ:
// vulkan.VkCopyDescriptorSetᵖ{Uint64,Uint32}
const schema::Entity* VkCopyDescriptorSet__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCopyDescriptorSetᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCopyDescriptorSetᶜᵖ:
// vulkan.VkCopyDescriptorSetᶜᵖ{Uint64,Uint32}
const schema::Entity* VkCopyDescriptorSet__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCopyDescriptorSetᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSurfaceKHRᵖ:
// vulkan.VkSurfaceKHRᵖ{Uint64,Uint32}
const schema::Entity* VkSurfaceKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSurfaceKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateAndroidSurfaceKHR:
// vulkan.VkCreateAndroidSurfaceKHR{[]?,Uint64,$,$,$,Uint32}
void VkCreateAndroidSurfaceKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mInstance);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPSurface);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateAndroidSurfaceKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateAndroidSurfaceKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Instance", new schema::Primitive{"VkInstance", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkAndroidSurfaceCreateInfoKHR__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PSurface", new schema::Struct{ VkSurfaceKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateBuffer:
// vulkan.VkCreateBuffer{[]?,Uint64,$,$,$,Uint32}
void VkCreateBuffer::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPBuffer);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateBuffer::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateBuffer",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkBufferCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PBuffer", new schema::Struct{ VkBuffer__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateBufferView:
// vulkan.VkCreateBufferView{[]?,Uint64,$,$,$,Uint32}
void VkCreateBufferView::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPView);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateBufferView::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateBufferView",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkBufferViewCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PView", new schema::Struct{ VkBufferView__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateCommandPool:
// vulkan.VkCreateCommandPool{[]?,Uint64,$,$,$,Uint32}
void VkCreateCommandPool::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPCommandPool);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateCommandPool::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateCommandPool",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkCommandPoolCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PCommandPool", new schema::Struct{ VkCommandPool__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineᵖ:
// vulkan.VkPipelineᵖ{Uint64,Uint32}
const schema::Entity* VkPipeline__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateComputePipelines:
// vulkan.VkCreateComputePipelines{[]?,Uint64,Uint64,Uint32,$,$,$,Uint32}
void VkCreateComputePipelines::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mPipelineCache);
    e->Uint32(this->mCreateInfoCount);
    e->Struct(this->mPCreateInfos);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPPipelines);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateComputePipelines::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateComputePipelines",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PipelineCache", new schema::Primitive{"VkPipelineCache", schema::Primitive::Uint64}},
            schema::Field{"CreateInfoCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PCreateInfos", new schema::Struct{ VkComputePipelineCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PPipelines", new schema::Struct{ VkPipeline__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDebugReportCallbackCreateInfoEXTᶜᵖ:
// vulkan.VkDebugReportCallbackCreateInfoEXTᶜᵖ{Uint64,Uint32}
const schema::Entity* VkDebugReportCallbackCreateInfoEXT__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDebugReportCallbackCreateInfoEXTᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDebugReportCallbackEXTᵖ:
// vulkan.VkDebugReportCallbackEXTᵖ{Uint64,Uint32}
const schema::Entity* VkDebugReportCallbackEXT__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDebugReportCallbackEXTᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateDebugReportCallbackEXT:
// vulkan.VkCreateDebugReportCallbackEXT{[]?,Uint64,$,$,$,Uint32}
void VkCreateDebugReportCallbackEXT::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mInstance);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPCallback);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateDebugReportCallbackEXT::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateDebugReportCallbackEXT",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Instance", new schema::Primitive{"VkInstance", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkDebugReportCallbackCreateInfoEXT__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PCallback", new schema::Struct{ VkDebugReportCallbackEXT__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorPoolCreateInfoᶜᵖ:
// vulkan.VkDescriptorPoolCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorPoolCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorPoolCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorPoolᵖ:
// vulkan.VkDescriptorPoolᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorPool__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorPoolᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateDescriptorPool:
// vulkan.VkCreateDescriptorPool{[]?,Uint64,$,$,$,Uint32}
void VkCreateDescriptorPool::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPDescriptorPool);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateDescriptorPool::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateDescriptorPool",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkDescriptorPoolCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PDescriptorPool", new schema::Struct{ VkDescriptorPool__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorSetLayoutCreateInfoᶜᵖ:
// vulkan.VkDescriptorSetLayoutCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorSetLayoutCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetLayoutCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorSetLayoutᵖ:
// vulkan.VkDescriptorSetLayoutᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorSetLayout__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetLayoutᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateDescriptorSetLayout:
// vulkan.VkCreateDescriptorSetLayout{[]?,Uint64,$,$,$,Uint32}
void VkCreateDescriptorSetLayout::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPSetLayout);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateDescriptorSetLayout::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateDescriptorSetLayout",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkDescriptorSetLayoutCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PSetLayout", new schema::Struct{ VkDescriptorSetLayout__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateDevice:
// vulkan.VkCreateDevice{[]?,Uint64,$,$,$,Uint32}
void VkCreateDevice::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPDevice);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateDevice::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateDevice",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkDeviceCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PDevice", new schema::Struct{ VkDevice__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDisplayModeCreateInfoKHRᶜᵖ:
// vulkan.VkDisplayModeCreateInfoKHRᶜᵖ{Uint64,Uint32}
const schema::Entity* VkDisplayModeCreateInfoKHR__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayModeCreateInfoKHRᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDisplayModeKHRᵖ:
// vulkan.VkDisplayModeKHRᵖ{Uint64,Uint32}
const schema::Entity* VkDisplayModeKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayModeKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateDisplayModeKHR:
// vulkan.VkCreateDisplayModeKHR{[]?,Uint64,Uint64,$,$,$,Uint32}
void VkCreateDisplayModeKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Uint64(this->mDisplay);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPMode);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateDisplayModeKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateDisplayModeKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"Display", new schema::Primitive{"VkDisplayKHR", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkDisplayModeCreateInfoKHR__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PMode", new schema::Struct{ VkDisplayModeKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDisplaySurfaceCreateInfoKHRᶜᵖ:
// vulkan.VkDisplaySurfaceCreateInfoKHRᶜᵖ{Uint64,Uint32}
const schema::Entity* VkDisplaySurfaceCreateInfoKHR__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplaySurfaceCreateInfoKHRᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateDisplayPlaneSurfaceKHR:
// vulkan.VkCreateDisplayPlaneSurfaceKHR{[]?,Uint64,$,$,$,Uint32}
void VkCreateDisplayPlaneSurfaceKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mInstance);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPSurface);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateDisplayPlaneSurfaceKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateDisplayPlaneSurfaceKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Instance", new schema::Primitive{"VkInstance", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkDisplaySurfaceCreateInfoKHR__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PSurface", new schema::Struct{ VkSurfaceKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkEventCreateInfoᶜᵖ:
// vulkan.VkEventCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkEventCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkEventCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkEventᵖ:
// vulkan.VkEventᵖ{Uint64,Uint32}
const schema::Entity* VkEvent__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkEventᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateEvent:
// vulkan.VkCreateEvent{[]?,Uint64,$,$,$,Uint32}
void VkCreateEvent::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPEvent);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateEvent::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateEvent",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkEventCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PEvent", new schema::Struct{ VkEvent__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkFenceCreateInfoᶜᵖ:
// vulkan.VkFenceCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkFenceCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFenceCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkFenceᵖ:
// vulkan.VkFenceᵖ{Uint64,Uint32}
const schema::Entity* VkFence__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFenceᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateFence:
// vulkan.VkCreateFence{[]?,Uint64,$,$,$,Uint32}
void VkCreateFence::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPFence);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateFence::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateFence",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkFenceCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PFence", new schema::Struct{ VkFence__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkFramebufferCreateInfoᶜᵖ:
// vulkan.VkFramebufferCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkFramebufferCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFramebufferCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkFramebufferᵖ:
// vulkan.VkFramebufferᵖ{Uint64,Uint32}
const schema::Entity* VkFramebuffer__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFramebufferᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateFramebuffer:
// vulkan.VkCreateFramebuffer{[]?,Uint64,$,$,$,Uint32}
void VkCreateFramebuffer::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPFramebuffer);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateFramebuffer::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateFramebuffer",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkFramebufferCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PFramebuffer", new schema::Struct{ VkFramebuffer__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGraphicsPipelineCreateInfoᶜᵖ:
// vulkan.VkGraphicsPipelineCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkGraphicsPipelineCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGraphicsPipelineCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateGraphicsPipelines:
// vulkan.VkCreateGraphicsPipelines{[]?,Uint64,Uint64,Uint32,$,$,$,Uint32}
void VkCreateGraphicsPipelines::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mPipelineCache);
    e->Uint32(this->mCreateInfoCount);
    e->Struct(this->mPCreateInfos);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPPipelines);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateGraphicsPipelines::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateGraphicsPipelines",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PipelineCache", new schema::Primitive{"VkPipelineCache", schema::Primitive::Uint64}},
            schema::Field{"CreateInfoCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PCreateInfos", new schema::Struct{ VkGraphicsPipelineCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PPipelines", new schema::Struct{ VkPipeline__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageCreateInfoᶜᵖ:
// vulkan.VkImageCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkImageCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageᵖ:
// vulkan.VkImageᵖ{Uint64,Uint32}
const schema::Entity* VkImage__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateImage:
// vulkan.VkCreateImage{[]?,Uint64,$,$,$,Uint32}
void VkCreateImage::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPImage);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateImage::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateImage",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkImageCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PImage", new schema::Struct{ VkImage__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageViewCreateInfoᶜᵖ:
// vulkan.VkImageViewCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkImageViewCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageViewCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageViewᵖ:
// vulkan.VkImageViewᵖ{Uint64,Uint32}
const schema::Entity* VkImageView__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageViewᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateImageView:
// vulkan.VkCreateImageView{[]?,Uint64,$,$,$,Uint32}
void VkCreateImageView::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPView);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateImageView::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateImageView",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkImageViewCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PView", new schema::Struct{ VkImageView__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateInstance:
// vulkan.VkCreateInstance{[]?,$,$,$,Uint32}
void VkCreateInstance::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPInstance);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateInstance::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateInstance",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkInstanceCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PInstance", new schema::Struct{ VkInstance__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMirSurfaceCreateInfoKHRᶜᵖ:
// vulkan.VkMirSurfaceCreateInfoKHRᶜᵖ{Uint64,Uint32}
const schema::Entity* VkMirSurfaceCreateInfoKHR__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMirSurfaceCreateInfoKHRᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateMirSurfaceKHR:
// vulkan.VkCreateMirSurfaceKHR{[]?,Uint64,$,$,$,Uint32}
void VkCreateMirSurfaceKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mInstance);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPSurface);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateMirSurfaceKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateMirSurfaceKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Instance", new schema::Primitive{"VkInstance", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkMirSurfaceCreateInfoKHR__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PSurface", new schema::Struct{ VkSurfaceKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineCacheCreateInfoᶜᵖ:
// vulkan.VkPipelineCacheCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineCacheCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineCacheCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineCacheᵖ:
// vulkan.VkPipelineCacheᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineCache__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineCacheᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreatePipelineCache:
// vulkan.VkCreatePipelineCache{[]?,Uint64,$,$,$,Uint32}
void VkCreatePipelineCache::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPPipelineCache);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreatePipelineCache::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreatePipelineCache",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkPipelineCacheCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PPipelineCache", new schema::Struct{ VkPipelineCache__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineLayoutCreateInfoᶜᵖ:
// vulkan.VkPipelineLayoutCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineLayoutCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineLayoutCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineLayoutᵖ:
// vulkan.VkPipelineLayoutᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineLayout__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineLayoutᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreatePipelineLayout:
// vulkan.VkCreatePipelineLayout{[]?,Uint64,$,$,$,Uint32}
void VkCreatePipelineLayout::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPPipelineLayout);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreatePipelineLayout::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreatePipelineLayout",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkPipelineLayoutCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PPipelineLayout", new schema::Struct{ VkPipelineLayout__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkQueryPoolCreateInfoᶜᵖ:
// vulkan.VkQueryPoolCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkQueryPoolCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkQueryPoolCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkQueryPoolᵖ:
// vulkan.VkQueryPoolᵖ{Uint64,Uint32}
const schema::Entity* VkQueryPool__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkQueryPoolᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateQueryPool:
// vulkan.VkCreateQueryPool{[]?,Uint64,$,$,$,Uint32}
void VkCreateQueryPool::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPQueryPool);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateQueryPool::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateQueryPool",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkQueryPoolCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PQueryPool", new schema::Struct{ VkQueryPool__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkRenderPassCreateInfoᶜᵖ:
// vulkan.VkRenderPassCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkRenderPassCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkRenderPassCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkRenderPassᵖ:
// vulkan.VkRenderPassᵖ{Uint64,Uint32}
const schema::Entity* VkRenderPass__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkRenderPassᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateRenderPass:
// vulkan.VkCreateRenderPass{[]?,Uint64,$,$,$,Uint32}
void VkCreateRenderPass::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPRenderPass);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateRenderPass::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateRenderPass",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkRenderPassCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PRenderPass", new schema::Struct{ VkRenderPass__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSamplerCreateInfoᶜᵖ:
// vulkan.VkSamplerCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkSamplerCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSamplerCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSamplerᵖ:
// vulkan.VkSamplerᵖ{Uint64,Uint32}
const schema::Entity* VkSampler__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSamplerᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateSampler:
// vulkan.VkCreateSampler{[]?,Uint64,$,$,$,Uint32}
void VkCreateSampler::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPSampler);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateSampler::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateSampler",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkSamplerCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PSampler", new schema::Struct{ VkSampler__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSemaphoreCreateInfoᶜᵖ:
// vulkan.VkSemaphoreCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkSemaphoreCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSemaphoreCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSemaphoreᵖ:
// vulkan.VkSemaphoreᵖ{Uint64,Uint32}
const schema::Entity* VkSemaphore__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSemaphoreᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateSemaphore:
// vulkan.VkCreateSemaphore{[]?,Uint64,$,$,$,Uint32}
void VkCreateSemaphore::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPSemaphore);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateSemaphore::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateSemaphore",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkSemaphoreCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PSemaphore", new schema::Struct{ VkSemaphore__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkShaderModuleCreateInfoᶜᵖ:
// vulkan.VkShaderModuleCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkShaderModuleCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkShaderModuleCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkShaderModuleᵖ:
// vulkan.VkShaderModuleᵖ{Uint64,Uint32}
const schema::Entity* VkShaderModule__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkShaderModuleᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateShaderModule:
// vulkan.VkCreateShaderModule{[]?,Uint64,$,$,$,Uint32}
void VkCreateShaderModule::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPShaderModule);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateShaderModule::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateShaderModule",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkShaderModuleCreateInfo__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PShaderModule", new schema::Struct{ VkShaderModule__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSwapchainCreateInfoKHRᶜᵖ:
// vulkan.VkSwapchainCreateInfoKHRᶜᵖ{Uint64,Uint32}
const schema::Entity* VkSwapchainCreateInfoKHR__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSwapchainCreateInfoKHRᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateSharedSwapchainsKHR:
// vulkan.VkCreateSharedSwapchainsKHR{[]?,Uint64,Uint32,$,$,$,Uint32}
void VkCreateSharedSwapchainsKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint32(this->mSwapchainCount);
    e->Struct(this->mPCreateInfos);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPSwapchains);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateSharedSwapchainsKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateSharedSwapchainsKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"SwapchainCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PCreateInfos", new schema::Struct{ VkSwapchainCreateInfoKHR__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PSwapchains", new schema::Struct{ VkSwapchainKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateSwapchainKHR:
// vulkan.VkCreateSwapchainKHR{[]?,Uint64,$,$,$,Uint32}
void VkCreateSwapchainKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPSwapchain);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateSwapchainKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateSwapchainKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkSwapchainCreateInfoKHR__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PSwapchain", new schema::Struct{ VkSwapchainKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkWaylandSurfaceCreateInfoKHRᶜᵖ:
// vulkan.VkWaylandSurfaceCreateInfoKHRᶜᵖ{Uint64,Uint32}
const schema::Entity* VkWaylandSurfaceCreateInfoKHR__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkWaylandSurfaceCreateInfoKHRᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateWaylandSurfaceKHR:
// vulkan.VkCreateWaylandSurfaceKHR{[]?,Uint64,$,$,$,Uint32}
void VkCreateWaylandSurfaceKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mInstance);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPSurface);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateWaylandSurfaceKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateWaylandSurfaceKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Instance", new schema::Primitive{"VkInstance", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkWaylandSurfaceCreateInfoKHR__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PSurface", new schema::Struct{ VkSurfaceKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkXcbSurfaceCreateInfoKHRᶜᵖ:
// vulkan.VkXcbSurfaceCreateInfoKHRᶜᵖ{Uint64,Uint32}
const schema::Entity* VkXcbSurfaceCreateInfoKHR__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkXcbSurfaceCreateInfoKHRᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateXcbSurfaceKHR:
// vulkan.VkCreateXcbSurfaceKHR{[]?,Uint64,$,$,$,Uint32}
void VkCreateXcbSurfaceKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mInstance);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPSurface);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateXcbSurfaceKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateXcbSurfaceKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Instance", new schema::Primitive{"VkInstance", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkXcbSurfaceCreateInfoKHR__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PSurface", new schema::Struct{ VkSurfaceKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkXlibSurfaceCreateInfoKHRᶜᵖ:
// vulkan.VkXlibSurfaceCreateInfoKHRᶜᵖ{Uint64,Uint32}
const schema::Entity* VkXlibSurfaceCreateInfoKHR__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkXlibSurfaceCreateInfoKHRᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkCreateXlibSurfaceKHR:
// vulkan.VkCreateXlibSurfaceKHR{[]?,Uint64,$,$,$,Uint32}
void VkCreateXlibSurfaceKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mInstance);
    e->Struct(this->mPCreateInfo);
    e->Struct(this->mPAllocator);
    e->Struct(this->mPSurface);
    e->Uint32(this->mResult);
}
const schema::Entity* VkCreateXlibSurfaceKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkCreateXlibSurfaceKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Instance", new schema::Primitive{"VkInstance", schema::Primitive::Uint64}},
            schema::Field{"PCreateInfo", new schema::Struct{ VkXlibSurfaceCreateInfoKHR__CP::StaticSchema()}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
            schema::Field{"PSurface", new schema::Struct{ VkSurfaceKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDebugReportCallbackCreateInfoEXT:
// vulkan.VkDebugReportCallbackCreateInfoEXT{Uint32,$,Uint32,$,$}
void VkDebugReportCallbackCreateInfoEXT::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Struct(this->mPfnCallback);
    e->Struct(this->mPUserData);
}
const schema::Entity* VkDebugReportCallbackCreateInfoEXT::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDebugReportCallbackCreateInfoEXT",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkDebugReportFlagsEXT", schema::Primitive::Uint32}},
            schema::Field{"PfnCallback", new schema::Struct{ PFN_vkDebugReportCallbackEXT::StaticSchema()}},
            schema::Field{"PUserData", new schema::Struct{ Void__P::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDebugReportCallbackCreateInfoEXTˢ:
// vulkan.VkDebugReportCallbackCreateInfoEXTˢ{$}
const schema::Entity* VkDebugReportCallbackCreateInfoEXT__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDebugReportCallbackCreateInfoEXTˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDebugReportCallbackCreateInfoEXTᵖ:
// vulkan.VkDebugReportCallbackCreateInfoEXTᵖ{Uint64,Uint32}
const schema::Entity* VkDebugReportCallbackCreateInfoEXT__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDebugReportCallbackCreateInfoEXTᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDebugReportCallbackEXTˢ:
// vulkan.VkDebugReportCallbackEXTˢ{$}
const schema::Entity* VkDebugReportCallbackEXT__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDebugReportCallbackEXTˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDebugReportMessageEXT:
// vulkan.VkDebugReportMessageEXT{[]?,Uint64,Uint32,Uint32,Uint64,Uint64,Int32,String,String}
void VkDebugReportMessageEXT::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mInstance);
    e->Uint32(this->mFlags);
    e->Uint32(this->mObjectType);
    e->Uint64(this->mObject);
    e->Uint64(this->mLocation);
    e->Int32(this->mMessageCode);
    e->String(this->mPLayerPrefix);
    e->String(this->mPMessage);
}
const schema::Entity* VkDebugReportMessageEXT::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDebugReportMessageEXT",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Instance", new schema::Primitive{"VkInstance", schema::Primitive::Uint64}},
            schema::Field{"Flags", new schema::Primitive{"VkDebugReportFlagsEXT", schema::Primitive::Uint32}},
            schema::Field{"ObjectType", new schema::Primitive{"VkDebugReportObjectTypeEXT", schema::Primitive::Uint32}},
            schema::Field{"Object", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Location", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"MessageCode", new schema::Primitive{"int32", schema::Primitive::Int32}},
            schema::Field{"PLayerPrefix", new schema::Primitive{"string", schema::Primitive::String}},
            schema::Field{"PMessage", new schema::Primitive{"string", schema::Primitive::String}},
        },
    };
    return &entity;
}

// VkDedicatedAllocationBufferCreateInfoNV:
// vulkan.VkDedicatedAllocationBufferCreateInfoNV{Uint32,$,Uint32}
const schema::Entity* VkDedicatedAllocationBufferCreateInfoNV::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDedicatedAllocationBufferCreateInfoNV",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"DedicatedAllocation", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDedicatedAllocationBufferCreateInfoNVˢ:
// vulkan.VkDedicatedAllocationBufferCreateInfoNVˢ{$}
const schema::Entity* VkDedicatedAllocationBufferCreateInfoNV__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDedicatedAllocationBufferCreateInfoNVˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDedicatedAllocationBufferCreateInfoNVᵖ:
// vulkan.VkDedicatedAllocationBufferCreateInfoNVᵖ{Uint64,Uint32}
const schema::Entity* VkDedicatedAllocationBufferCreateInfoNV__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDedicatedAllocationBufferCreateInfoNVᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDedicatedAllocationImageCreateInfoNV:
// vulkan.VkDedicatedAllocationImageCreateInfoNV{Uint32,$,Uint32}
const schema::Entity* VkDedicatedAllocationImageCreateInfoNV::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDedicatedAllocationImageCreateInfoNV",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"DedicatedAllocation", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDedicatedAllocationImageCreateInfoNVˢ:
// vulkan.VkDedicatedAllocationImageCreateInfoNVˢ{$}
const schema::Entity* VkDedicatedAllocationImageCreateInfoNV__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDedicatedAllocationImageCreateInfoNVˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDedicatedAllocationImageCreateInfoNVᵖ:
// vulkan.VkDedicatedAllocationImageCreateInfoNVᵖ{Uint64,Uint32}
const schema::Entity* VkDedicatedAllocationImageCreateInfoNV__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDedicatedAllocationImageCreateInfoNVᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDedicatedAllocationMemoryAllocateInfoNV:
// vulkan.VkDedicatedAllocationMemoryAllocateInfoNV{Uint32,$,Uint64,Uint64}
void VkDedicatedAllocationMemoryAllocateInfoNV::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint64(this->mImage);
    e->Uint64(this->mBuffer);
}
const schema::Entity* VkDedicatedAllocationMemoryAllocateInfoNV::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDedicatedAllocationMemoryAllocateInfoNV",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Image", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"Buffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// VkDedicatedAllocationMemoryAllocateInfoNVˢ:
// vulkan.VkDedicatedAllocationMemoryAllocateInfoNVˢ{$}
const schema::Entity* VkDedicatedAllocationMemoryAllocateInfoNV__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDedicatedAllocationMemoryAllocateInfoNVˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDedicatedAllocationMemoryAllocateInfoNVᵖ:
// vulkan.VkDedicatedAllocationMemoryAllocateInfoNVᵖ{Uint64,Uint32}
const schema::Entity* VkDedicatedAllocationMemoryAllocateInfoNV__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDedicatedAllocationMemoryAllocateInfoNVᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorBufferInfoˢ:
// vulkan.VkDescriptorBufferInfoˢ{$}
const schema::Entity* VkDescriptorBufferInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorBufferInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDescriptorBufferInfoᵖ:
// vulkan.VkDescriptorBufferInfoᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorBufferInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorBufferInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorBufferInfoᶜᵖ:
// vulkan.VkDescriptorBufferInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorBufferInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorBufferInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorImageInfo:
// vulkan.VkDescriptorImageInfo{Uint64,Uint64,Uint32}
const schema::Entity* VkDescriptorImageInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorImageInfo",
        "",
        {
            schema::Field{"Sampler", new schema::Primitive{"VkSampler", schema::Primitive::Uint64}},
            schema::Field{"ImageView", new schema::Primitive{"VkImageView", schema::Primitive::Uint64}},
            schema::Field{"ImageLayout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorImageInfoˢ:
// vulkan.VkDescriptorImageInfoˢ{$}
const schema::Entity* VkDescriptorImageInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorImageInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDescriptorImageInfoᵖ:
// vulkan.VkDescriptorImageInfoᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorImageInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorImageInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorImageInfoᶜᵖ:
// vulkan.VkDescriptorImageInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorImageInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorImageInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorPoolSizeᶜᵖ:
// vulkan.VkDescriptorPoolSizeᶜᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorPoolSize__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorPoolSizeᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorPoolCreateInfo:
// vulkan.VkDescriptorPoolCreateInfo{Uint32,$,Uint32,Uint32,Uint32,$}
void VkDescriptorPoolCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mMaxSets);
    e->Uint32(this->mPoolSizeCount);
    e->Struct(this->mPPoolSizes);
}
const schema::Entity* VkDescriptorPoolCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorPoolCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkDescriptorPoolCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"MaxSets", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PoolSizeCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PPoolSizes", new schema::Struct{ VkDescriptorPoolSize__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDescriptorPoolCreateInfoˢ:
// vulkan.VkDescriptorPoolCreateInfoˢ{$}
const schema::Entity* VkDescriptorPoolCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorPoolCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDescriptorPoolCreateInfoᵖ:
// vulkan.VkDescriptorPoolCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorPoolCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorPoolCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorPoolSize:
// vulkan.VkDescriptorPoolSize{Uint32,Uint32}
const schema::Entity* VkDescriptorPoolSize::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorPoolSize",
        "",
        {
            schema::Field{"Type", new schema::Primitive{"VkDescriptorType", schema::Primitive::Uint32}},
            schema::Field{"DescriptorCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorPoolSizeˢ:
// vulkan.VkDescriptorPoolSizeˢ{$}
const schema::Entity* VkDescriptorPoolSize__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorPoolSizeˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDescriptorPoolSizeᵖ:
// vulkan.VkDescriptorPoolSizeᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorPoolSize__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorPoolSizeᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorPoolˢ:
// vulkan.VkDescriptorPoolˢ{$}
const schema::Entity* VkDescriptorPool__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorPoolˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDescriptorSetLayoutᶜᵖ:
// vulkan.VkDescriptorSetLayoutᶜᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorSetLayout__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetLayoutᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorSetAllocateInfo:
// vulkan.VkDescriptorSetAllocateInfo{Uint32,$,Uint64,Uint32,$}
void VkDescriptorSetAllocateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint64(this->mDescriptorPool);
    e->Uint32(this->mDescriptorSetCount);
    e->Struct(this->mPSetLayouts);
}
const schema::Entity* VkDescriptorSetAllocateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetAllocateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"DescriptorPool", new schema::Primitive{"VkDescriptorPool", schema::Primitive::Uint64}},
            schema::Field{"DescriptorSetCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PSetLayouts", new schema::Struct{ VkDescriptorSetLayout__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDescriptorSetAllocateInfoˢ:
// vulkan.VkDescriptorSetAllocateInfoˢ{$}
const schema::Entity* VkDescriptorSetAllocateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetAllocateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDescriptorSetAllocateInfoᵖ:
// vulkan.VkDescriptorSetAllocateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorSetAllocateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetAllocateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSamplerᶜᵖ:
// vulkan.VkSamplerᶜᵖ{Uint64,Uint32}
const schema::Entity* VkSampler__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSamplerᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorSetLayoutBinding:
// vulkan.VkDescriptorSetLayoutBinding{Uint32,Uint32,Uint32,Uint32,$}
void VkDescriptorSetLayoutBinding::Encode(Encoder* e) const {
    e->Uint32(this->mBinding);
    e->Uint32(this->mDescriptorType);
    e->Uint32(this->mDescriptorCount);
    e->Uint32(this->mStageFlags);
    e->Struct(this->mPImmutableSamplers);
}
const schema::Entity* VkDescriptorSetLayoutBinding::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetLayoutBinding",
        "",
        {
            schema::Field{"Binding", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"DescriptorType", new schema::Primitive{"VkDescriptorType", schema::Primitive::Uint32}},
            schema::Field{"DescriptorCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"StageFlags", new schema::Primitive{"VkShaderStageFlags", schema::Primitive::Uint32}},
            schema::Field{"PImmutableSamplers", new schema::Struct{ VkSampler__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDescriptorSetLayoutBindingˢ:
// vulkan.VkDescriptorSetLayoutBindingˢ{$}
const schema::Entity* VkDescriptorSetLayoutBinding__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetLayoutBindingˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDescriptorSetLayoutBindingᵖ:
// vulkan.VkDescriptorSetLayoutBindingᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorSetLayoutBinding__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetLayoutBindingᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorSetLayoutBindingᶜᵖ:
// vulkan.VkDescriptorSetLayoutBindingᶜᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorSetLayoutBinding__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetLayoutBindingᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorSetLayoutCreateInfo:
// vulkan.VkDescriptorSetLayoutCreateInfo{Uint32,$,Uint32,Uint32,$}
void VkDescriptorSetLayoutCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mBindingCount);
    e->Struct(this->mPBindings);
}
const schema::Entity* VkDescriptorSetLayoutCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetLayoutCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkDescriptorSetLayoutCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"BindingCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PBindings", new schema::Struct{ VkDescriptorSetLayoutBinding__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDescriptorSetLayoutCreateInfoˢ:
// vulkan.VkDescriptorSetLayoutCreateInfoˢ{$}
const schema::Entity* VkDescriptorSetLayoutCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetLayoutCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDescriptorSetLayoutCreateInfoᵖ:
// vulkan.VkDescriptorSetLayoutCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkDescriptorSetLayoutCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetLayoutCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDescriptorSetLayoutˢ:
// vulkan.VkDescriptorSetLayoutˢ{$}
const schema::Entity* VkDescriptorSetLayout__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetLayoutˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDescriptorSetˢ:
// vulkan.VkDescriptorSetˢ{$}
const schema::Entity* VkDescriptorSet__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDescriptorSetˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyBuffer:
// vulkan.VkDestroyBuffer{[]?,Uint64,Uint64,$}
void VkDestroyBuffer::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mBuffer);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyBuffer::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyBuffer",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Buffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyBufferView:
// vulkan.VkDestroyBufferView{[]?,Uint64,Uint64,$}
void VkDestroyBufferView::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mBufferView);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyBufferView::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyBufferView",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"BufferView", new schema::Primitive{"VkBufferView", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyCommandPool:
// vulkan.VkDestroyCommandPool{[]?,Uint64,Uint64,$}
void VkDestroyCommandPool::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mCommandPool);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyCommandPool::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyCommandPool",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"CommandPool", new schema::Primitive{"VkCommandPool", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyDebugReportCallbackEXT:
// vulkan.VkDestroyDebugReportCallbackEXT{[]?,Uint64,Uint64,$}
void VkDestroyDebugReportCallbackEXT::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mInstance);
    e->Uint64(this->mCallback);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyDebugReportCallbackEXT::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyDebugReportCallbackEXT",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Instance", new schema::Primitive{"VkInstance", schema::Primitive::Uint64}},
            schema::Field{"Callback", new schema::Primitive{"VkDebugReportCallbackEXT", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyDescriptorPool:
// vulkan.VkDestroyDescriptorPool{[]?,Uint64,Uint64,$}
void VkDestroyDescriptorPool::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mDescriptorPool);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyDescriptorPool::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyDescriptorPool",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"DescriptorPool", new schema::Primitive{"VkDescriptorPool", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyDescriptorSetLayout:
// vulkan.VkDestroyDescriptorSetLayout{[]?,Uint64,Uint64,$}
void VkDestroyDescriptorSetLayout::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mDescriptorSetLayout);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyDescriptorSetLayout::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyDescriptorSetLayout",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"DescriptorSetLayout", new schema::Primitive{"VkDescriptorSetLayout", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyDevice:
// vulkan.VkDestroyDevice{[]?,Uint64,$}
const schema::Entity* VkDestroyDevice::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyDevice",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyEvent:
// vulkan.VkDestroyEvent{[]?,Uint64,Uint64,$}
void VkDestroyEvent::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mEvent);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyEvent::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyEvent",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Event", new schema::Primitive{"VkEvent", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyFence:
// vulkan.VkDestroyFence{[]?,Uint64,Uint64,$}
void VkDestroyFence::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mFence);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyFence::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyFence",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Fence", new schema::Primitive{"VkFence", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyFramebuffer:
// vulkan.VkDestroyFramebuffer{[]?,Uint64,Uint64,$}
void VkDestroyFramebuffer::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mFramebuffer);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyFramebuffer::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyFramebuffer",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Framebuffer", new schema::Primitive{"VkFramebuffer", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyImage:
// vulkan.VkDestroyImage{[]?,Uint64,Uint64,$}
void VkDestroyImage::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mImage);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyImage::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyImage",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Image", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyImageView:
// vulkan.VkDestroyImageView{[]?,Uint64,Uint64,$}
void VkDestroyImageView::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mImageView);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyImageView::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyImageView",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"ImageView", new schema::Primitive{"VkImageView", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyInstance:
// vulkan.VkDestroyInstance{[]?,Uint64,$}
const schema::Entity* VkDestroyInstance::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyInstance",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Instance", new schema::Primitive{"VkInstance", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyPipeline:
// vulkan.VkDestroyPipeline{[]?,Uint64,Uint64,$}
void VkDestroyPipeline::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mPipeline);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyPipeline::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyPipeline",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Pipeline", new schema::Primitive{"VkPipeline", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyPipelineCache:
// vulkan.VkDestroyPipelineCache{[]?,Uint64,Uint64,$}
void VkDestroyPipelineCache::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mPipelineCache);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyPipelineCache::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyPipelineCache",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PipelineCache", new schema::Primitive{"VkPipelineCache", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyPipelineLayout:
// vulkan.VkDestroyPipelineLayout{[]?,Uint64,Uint64,$}
void VkDestroyPipelineLayout::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mPipelineLayout);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyPipelineLayout::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyPipelineLayout",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PipelineLayout", new schema::Primitive{"VkPipelineLayout", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyQueryPool:
// vulkan.VkDestroyQueryPool{[]?,Uint64,Uint64,$}
void VkDestroyQueryPool::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mQueryPool);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyQueryPool::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyQueryPool",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"QueryPool", new schema::Primitive{"VkQueryPool", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyRenderPass:
// vulkan.VkDestroyRenderPass{[]?,Uint64,Uint64,$}
void VkDestroyRenderPass::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mRenderPass);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyRenderPass::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyRenderPass",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"RenderPass", new schema::Primitive{"VkRenderPass", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroySampler:
// vulkan.VkDestroySampler{[]?,Uint64,Uint64,$}
void VkDestroySampler::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mSampler);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroySampler::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroySampler",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Sampler", new schema::Primitive{"VkSampler", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroySemaphore:
// vulkan.VkDestroySemaphore{[]?,Uint64,Uint64,$}
void VkDestroySemaphore::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mSemaphore);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroySemaphore::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroySemaphore",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Semaphore", new schema::Primitive{"VkSemaphore", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroyShaderModule:
// vulkan.VkDestroyShaderModule{[]?,Uint64,Uint64,$}
void VkDestroyShaderModule::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mShaderModule);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroyShaderModule::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroyShaderModule",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"ShaderModule", new schema::Primitive{"VkShaderModule", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroySurfaceKHR:
// vulkan.VkDestroySurfaceKHR{[]?,Uint64,Uint64,$}
void VkDestroySurfaceKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mInstance);
    e->Uint64(this->mSurface);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroySurfaceKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroySurfaceKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Instance", new schema::Primitive{"VkInstance", schema::Primitive::Uint64}},
            schema::Field{"Surface", new schema::Primitive{"VkSurfaceKHR", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDestroySwapchainKHR:
// vulkan.VkDestroySwapchainKHR{[]?,Uint64,Uint64,$}
void VkDestroySwapchainKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mSwapchain);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkDestroySwapchainKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDestroySwapchainKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Swapchain", new schema::Primitive{"VkSwapchainKHR", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDeviceQueueCreateInfoᶜᵖ:
// vulkan.VkDeviceQueueCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkDeviceQueueCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDeviceQueueCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPhysicalDeviceFeaturesᶜᵖ:
// vulkan.VkPhysicalDeviceFeaturesᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPhysicalDeviceFeatures__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPhysicalDeviceFeaturesᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDeviceCreateInfo:
// vulkan.VkDeviceCreateInfo{Uint32,$,Uint32,Uint32,$,Uint32,$,Uint32,$,$}
void VkDeviceCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mQueueCreateInfoCount);
    e->Struct(this->mPQueueCreateInfos);
    e->Uint32(this->mEnabledLayerCount);
    e->Struct(this->mPpEnabledLayerNames);
    e->Uint32(this->mEnabledExtensionCount);
    e->Struct(this->mPpEnabledExtensionNames);
    e->Struct(this->mPEnabledFeatures);
}
const schema::Entity* VkDeviceCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDeviceCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkDeviceCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"QueueCreateInfoCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PQueueCreateInfos", new schema::Struct{ VkDeviceQueueCreateInfo__CP::StaticSchema()}},
            schema::Field{"EnabledLayerCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PpEnabledLayerNames", new schema::Struct{ Char__CP__CP::StaticSchema()}},
            schema::Field{"EnabledExtensionCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PpEnabledExtensionNames", new schema::Struct{ Char__CP__CP::StaticSchema()}},
            schema::Field{"PEnabledFeatures", new schema::Struct{ VkPhysicalDeviceFeatures__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDeviceCreateInfoˢ:
// vulkan.VkDeviceCreateInfoˢ{$}
const schema::Entity* VkDeviceCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDeviceCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDeviceMemoryˢ:
// vulkan.VkDeviceMemoryˢ{$}
const schema::Entity* VkDeviceMemory__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDeviceMemoryˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDeviceQueueCreateInfo:
// vulkan.VkDeviceQueueCreateInfo{Uint32,$,Uint32,Uint32,Uint32,$}
void VkDeviceQueueCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mQueueFamilyIndex);
    e->Uint32(this->mQueueCount);
    e->Struct(this->mPQueuePriorities);
}
const schema::Entity* VkDeviceQueueCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDeviceQueueCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkDeviceQueueCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"QueueFamilyIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"QueueCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PQueuePriorities", new schema::Struct{ F32__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDeviceQueueCreateInfoˢ:
// vulkan.VkDeviceQueueCreateInfoˢ{$}
const schema::Entity* VkDeviceQueueCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDeviceQueueCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDeviceQueueCreateInfoᵖ:
// vulkan.VkDeviceQueueCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkDeviceQueueCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDeviceQueueCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDeviceSizeˢ:
// vulkan.VkDeviceSizeˢ{$}
const schema::Entity* VkDeviceSize__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDeviceSizeˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDeviceSizeᵖ:
// vulkan.VkDeviceSizeᵖ{Uint64,Uint32}
const schema::Entity* VkDeviceSize__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDeviceSizeᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDeviceWaitIdle:
// vulkan.VkDeviceWaitIdle{[]?,Uint64,Uint32}
const schema::Entity* VkDeviceWaitIdle::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDeviceWaitIdle",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDeviceˢ:
// vulkan.VkDeviceˢ{$}
const schema::Entity* VkDevice__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDeviceˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDispatchIndirectCommand:
// vulkan.VkDispatchIndirectCommand{Uint32,Uint32,Uint32}
const schema::Entity* VkDispatchIndirectCommand::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDispatchIndirectCommand",
        "",
        {
            schema::Field{"X", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Y", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Z", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDisplayKHRˢ:
// vulkan.VkDisplayKHRˢ{$}
const schema::Entity* VkDisplayKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDisplayKHRᵖ:
// vulkan.VkDisplayKHRᵖ{Uint64,Uint32}
const schema::Entity* VkDisplayKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDisplayModeParametersKHR:
// vulkan.VkDisplayModeParametersKHR{$,Uint32}
const schema::Entity* VkDisplayModeParametersKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayModeParametersKHR",
        "",
        {
            schema::Field{"VisibleRegion", new schema::Struct{ VkExtent2D::StaticSchema()}},
            schema::Field{"RefreshRate", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDisplayModeCreateInfoKHR:
// vulkan.VkDisplayModeCreateInfoKHR{Uint32,$,Uint32,$}
void VkDisplayModeCreateInfoKHR::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Struct(this->mParameters);
}
const schema::Entity* VkDisplayModeCreateInfoKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayModeCreateInfoKHR",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkDisplayModeCreateFlagsKHR", schema::Primitive::Uint32}},
            schema::Field{"Parameters", new schema::Struct{ VkDisplayModeParametersKHR::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDisplayModeCreateInfoKHRˢ:
// vulkan.VkDisplayModeCreateInfoKHRˢ{$}
const schema::Entity* VkDisplayModeCreateInfoKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayModeCreateInfoKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDisplayModeCreateInfoKHRᵖ:
// vulkan.VkDisplayModeCreateInfoKHRᵖ{Uint64,Uint32}
const schema::Entity* VkDisplayModeCreateInfoKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayModeCreateInfoKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDisplayModeKHRˢ:
// vulkan.VkDisplayModeKHRˢ{$}
const schema::Entity* VkDisplayModeKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayModeKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDisplayModePropertiesKHR:
// vulkan.VkDisplayModePropertiesKHR{Uint64,$}
const schema::Entity* VkDisplayModePropertiesKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayModePropertiesKHR",
        "",
        {
            schema::Field{"DisplayMode", new schema::Primitive{"VkDisplayModeKHR", schema::Primitive::Uint64}},
            schema::Field{"Parameters", new schema::Struct{ VkDisplayModeParametersKHR::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDisplayModePropertiesKHRˢ:
// vulkan.VkDisplayModePropertiesKHRˢ{$}
const schema::Entity* VkDisplayModePropertiesKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayModePropertiesKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDisplayModePropertiesKHRᵖ:
// vulkan.VkDisplayModePropertiesKHRᵖ{Uint64,Uint32}
const schema::Entity* VkDisplayModePropertiesKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayModePropertiesKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDisplayPlaneCapabilitiesKHR:
// vulkan.VkDisplayPlaneCapabilitiesKHR{Uint32,$,$,$,$,$,$,$,$}
void VkDisplayPlaneCapabilitiesKHR::Encode(Encoder* e) const {
    e->Uint32(this->mSupportedAlpha);
    e->Struct(this->mMinSrcPosition);
    e->Struct(this->mMaxSrcPosition);
    e->Struct(this->mMinSrcExtent);
    e->Struct(this->mMaxSrcExtent);
    e->Struct(this->mMinDstPosition);
    e->Struct(this->mMaxDstPosition);
    e->Struct(this->mMinDstExtent);
    e->Struct(this->mMaxDstExtent);
}
const schema::Entity* VkDisplayPlaneCapabilitiesKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayPlaneCapabilitiesKHR",
        "",
        {
            schema::Field{"SupportedAlpha", new schema::Primitive{"VkDisplayPlaneAlphaFlagsKHR", schema::Primitive::Uint32}},
            schema::Field{"MinSrcPosition", new schema::Struct{ VkOffset2D::StaticSchema()}},
            schema::Field{"MaxSrcPosition", new schema::Struct{ VkOffset2D::StaticSchema()}},
            schema::Field{"MinSrcExtent", new schema::Struct{ VkExtent2D::StaticSchema()}},
            schema::Field{"MaxSrcExtent", new schema::Struct{ VkExtent2D::StaticSchema()}},
            schema::Field{"MinDstPosition", new schema::Struct{ VkOffset2D::StaticSchema()}},
            schema::Field{"MaxDstPosition", new schema::Struct{ VkOffset2D::StaticSchema()}},
            schema::Field{"MinDstExtent", new schema::Struct{ VkExtent2D::StaticSchema()}},
            schema::Field{"MaxDstExtent", new schema::Struct{ VkExtent2D::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDisplayPlaneCapabilitiesKHRˢ:
// vulkan.VkDisplayPlaneCapabilitiesKHRˢ{$}
const schema::Entity* VkDisplayPlaneCapabilitiesKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayPlaneCapabilitiesKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDisplayPlaneCapabilitiesKHRᵖ:
// vulkan.VkDisplayPlaneCapabilitiesKHRᵖ{Uint64,Uint32}
const schema::Entity* VkDisplayPlaneCapabilitiesKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayPlaneCapabilitiesKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDisplayPlanePropertiesKHR:
// vulkan.VkDisplayPlanePropertiesKHR{Uint64,Uint32}
const schema::Entity* VkDisplayPlanePropertiesKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayPlanePropertiesKHR",
        "",
        {
            schema::Field{"CurrentDisplay", new schema::Primitive{"VkDisplayKHR", schema::Primitive::Uint64}},
            schema::Field{"CurrentStackIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDisplayPlanePropertiesKHRˢ:
// vulkan.VkDisplayPlanePropertiesKHRˢ{$}
const schema::Entity* VkDisplayPlanePropertiesKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayPlanePropertiesKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDisplayPlanePropertiesKHRᵖ:
// vulkan.VkDisplayPlanePropertiesKHRᵖ{Uint64,Uint32}
const schema::Entity* VkDisplayPlanePropertiesKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayPlanePropertiesKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDisplayPresentInfoKHR:
// vulkan.VkDisplayPresentInfoKHR{Uint32,$,$,$,Uint32}
void VkDisplayPresentInfoKHR::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Struct(this->mSrcRect);
    e->Struct(this->mDstRect);
    e->Uint32(this->mPersistent);
}
const schema::Entity* VkDisplayPresentInfoKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayPresentInfoKHR",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"SrcRect", new schema::Struct{ VkRect2D::StaticSchema()}},
            schema::Field{"DstRect", new schema::Struct{ VkRect2D::StaticSchema()}},
            schema::Field{"Persistent", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDisplayPropertiesKHR:
// vulkan.VkDisplayPropertiesKHR{Uint64,String,$,$,Uint32,Uint32,Uint32}
void VkDisplayPropertiesKHR::Encode(Encoder* e) const {
    e->Uint64(this->mDisplay);
    e->String(this->mDisplayName);
    e->Struct(this->mPhysicalDimensions);
    e->Struct(this->mPhysicalResolution);
    e->Uint32(this->mSupportedTransforms);
    e->Uint32(this->mPlaneReorderPossible);
    e->Uint32(this->mPersistentContent);
}
const schema::Entity* VkDisplayPropertiesKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayPropertiesKHR",
        "",
        {
            schema::Field{"Display", new schema::Primitive{"VkDisplayKHR", schema::Primitive::Uint64}},
            schema::Field{"DisplayName", new schema::Primitive{"string", schema::Primitive::String}},
            schema::Field{"PhysicalDimensions", new schema::Struct{ VkExtent2D::StaticSchema()}},
            schema::Field{"PhysicalResolution", new schema::Struct{ VkExtent2D::StaticSchema()}},
            schema::Field{"SupportedTransforms", new schema::Primitive{"VkSurfaceTransformFlagsKHR", schema::Primitive::Uint32}},
            schema::Field{"PlaneReorderPossible", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"PersistentContent", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDisplayPropertiesKHRˢ:
// vulkan.VkDisplayPropertiesKHRˢ{$}
const schema::Entity* VkDisplayPropertiesKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayPropertiesKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDisplayPropertiesKHRᵖ:
// vulkan.VkDisplayPropertiesKHRᵖ{Uint64,Uint32}
const schema::Entity* VkDisplayPropertiesKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplayPropertiesKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDisplaySurfaceCreateInfoKHR:
// vulkan.VkDisplaySurfaceCreateInfoKHR{Uint32,$,Uint32,Uint64,Uint32,Uint32,Uint32,Float32,Uint32,$}
void VkDisplaySurfaceCreateInfoKHR::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint64(this->mDisplayMode);
    e->Uint32(this->mPlaneIndex);
    e->Uint32(this->mPlaneStackIndex);
    e->Uint32(this->mTransform);
    e->Float32(this->mGlobalAlpha);
    e->Uint32(this->mAlphaMode);
    e->Struct(this->mImageExtent);
}
const schema::Entity* VkDisplaySurfaceCreateInfoKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplaySurfaceCreateInfoKHR",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkDisplaySurfaceCreateFlagsKHR", schema::Primitive::Uint32}},
            schema::Field{"DisplayMode", new schema::Primitive{"VkDisplayModeKHR", schema::Primitive::Uint64}},
            schema::Field{"PlaneIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PlaneStackIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Transform", new schema::Primitive{"VkSurfaceTransformFlagBitsKHR", schema::Primitive::Uint32}},
            schema::Field{"GlobalAlpha", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"AlphaMode", new schema::Primitive{"VkDisplayPlaneAlphaFlagBitsKHR", schema::Primitive::Uint32}},
            schema::Field{"ImageExtent", new schema::Struct{ VkExtent2D::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDisplaySurfaceCreateInfoKHRˢ:
// vulkan.VkDisplaySurfaceCreateInfoKHRˢ{$}
const schema::Entity* VkDisplaySurfaceCreateInfoKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplaySurfaceCreateInfoKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDisplaySurfaceCreateInfoKHRᵖ:
// vulkan.VkDisplaySurfaceCreateInfoKHRᵖ{Uint64,Uint32}
const schema::Entity* VkDisplaySurfaceCreateInfoKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDisplaySurfaceCreateInfoKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDrawIndexedIndirectCommand:
// vulkan.VkDrawIndexedIndirectCommand{Uint32,Uint32,Uint32,Int32,Uint32}
void VkDrawIndexedIndirectCommand::Encode(Encoder* e) const {
    e->Uint32(this->mIndexCount);
    e->Uint32(this->mInstanceCount);
    e->Uint32(this->mFirstIndex);
    e->Int32(this->mVertexOffset);
    e->Uint32(this->mFirstInstance);
}
const schema::Entity* VkDrawIndexedIndirectCommand::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDrawIndexedIndirectCommand",
        "",
        {
            schema::Field{"IndexCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"InstanceCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"FirstIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"VertexOffset", new schema::Primitive{"int32", schema::Primitive::Int32}},
            schema::Field{"FirstInstance", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDrawIndirectCommand:
// vulkan.VkDrawIndirectCommand{Uint32,Uint32,Uint32,Uint32}
void VkDrawIndirectCommand::Encode(Encoder* e) const {
    e->Uint32(this->mVertexCount);
    e->Uint32(this->mInstanceCount);
    e->Uint32(this->mFirstVertex);
    e->Uint32(this->mFirstInstance);
}
const schema::Entity* VkDrawIndirectCommand::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDrawIndirectCommand",
        "",
        {
            schema::Field{"VertexCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"InstanceCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"FirstVertex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"FirstInstance", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDynamicStateˢ:
// vulkan.VkDynamicStateˢ{$}
const schema::Entity* VkDynamicState__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDynamicStateˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkDynamicStateᵖ:
// vulkan.VkDynamicStateᵖ{Uint64,Uint32}
const schema::Entity* VkDynamicState__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDynamicStateᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkDynamicStateᶜᵖ:
// vulkan.VkDynamicStateᶜᵖ{Uint64,Uint32}
const schema::Entity* VkDynamicState__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkDynamicStateᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkEndCommandBuffer:
// vulkan.VkEndCommandBuffer{[]?,Uint64,Uint32}
const schema::Entity* VkEndCommandBuffer::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkEndCommandBuffer",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkExtensionPropertiesᵖ:
// vulkan.VkExtensionPropertiesᵖ{Uint64,Uint32}
const schema::Entity* VkExtensionProperties__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkExtensionPropertiesᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkEnumerateDeviceExtensionProperties:
// vulkan.VkEnumerateDeviceExtensionProperties{[]?,Uint64,String,$,$,Uint32}
void VkEnumerateDeviceExtensionProperties::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->String(this->mPLayerName);
    e->Struct(this->mPPropertyCount);
    e->Struct(this->mPProperties);
    e->Uint32(this->mResult);
}
const schema::Entity* VkEnumerateDeviceExtensionProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkEnumerateDeviceExtensionProperties",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"PLayerName", new schema::Primitive{"string", schema::Primitive::String}},
            schema::Field{"PPropertyCount", new schema::Struct{ U32__P::StaticSchema()}},
            schema::Field{"PProperties", new schema::Struct{ VkExtensionProperties__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkLayerPropertiesᵖ:
// vulkan.VkLayerPropertiesᵖ{Uint64,Uint32}
const schema::Entity* VkLayerProperties__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkLayerPropertiesᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkEnumerateDeviceLayerProperties:
// vulkan.VkEnumerateDeviceLayerProperties{[]?,Uint64,$,$,Uint32}
void VkEnumerateDeviceLayerProperties::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Struct(this->mPPropertyCount);
    e->Struct(this->mPProperties);
    e->Uint32(this->mResult);
}
const schema::Entity* VkEnumerateDeviceLayerProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkEnumerateDeviceLayerProperties",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"PPropertyCount", new schema::Struct{ U32__P::StaticSchema()}},
            schema::Field{"PProperties", new schema::Struct{ VkLayerProperties__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkEnumerateInstanceExtensionProperties:
// vulkan.VkEnumerateInstanceExtensionProperties{[]?,String,$,$,Uint32}
void VkEnumerateInstanceExtensionProperties::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->String(this->mPLayerName);
    e->Struct(this->mPPropertyCount);
    e->Struct(this->mPProperties);
    e->Uint32(this->mResult);
}
const schema::Entity* VkEnumerateInstanceExtensionProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkEnumerateInstanceExtensionProperties",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PLayerName", new schema::Primitive{"string", schema::Primitive::String}},
            schema::Field{"PPropertyCount", new schema::Struct{ U32__P::StaticSchema()}},
            schema::Field{"PProperties", new schema::Struct{ VkExtensionProperties__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkEnumerateInstanceLayerProperties:
// vulkan.VkEnumerateInstanceLayerProperties{[]?,$,$,Uint32}
void VkEnumerateInstanceLayerProperties::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Struct(this->mPPropertyCount);
    e->Struct(this->mPProperties);
    e->Uint32(this->mResult);
}
const schema::Entity* VkEnumerateInstanceLayerProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkEnumerateInstanceLayerProperties",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PPropertyCount", new schema::Struct{ U32__P::StaticSchema()}},
            schema::Field{"PProperties", new schema::Struct{ VkLayerProperties__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPhysicalDeviceᵖ:
// vulkan.VkPhysicalDeviceᵖ{Uint64,Uint32}
const schema::Entity* VkPhysicalDevice__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPhysicalDeviceᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkEnumeratePhysicalDevices:
// vulkan.VkEnumeratePhysicalDevices{[]?,Uint64,$,$,Uint32}
void VkEnumeratePhysicalDevices::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mInstance);
    e->Struct(this->mPPhysicalDeviceCount);
    e->Struct(this->mPPhysicalDevices);
    e->Uint32(this->mResult);
}
const schema::Entity* VkEnumeratePhysicalDevices::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkEnumeratePhysicalDevices",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Instance", new schema::Primitive{"VkInstance", schema::Primitive::Uint64}},
            schema::Field{"PPhysicalDeviceCount", new schema::Struct{ U32__P::StaticSchema()}},
            schema::Field{"PPhysicalDevices", new schema::Struct{ VkPhysicalDevice__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkEventCreateInfo:
// vulkan.VkEventCreateInfo{Uint32,$,Uint32}
const schema::Entity* VkEventCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkEventCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkEventCreateFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkEventCreateInfoˢ:
// vulkan.VkEventCreateInfoˢ{$}
const schema::Entity* VkEventCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkEventCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkEventCreateInfoᵖ:
// vulkan.VkEventCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkEventCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkEventCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkEventˢ:
// vulkan.VkEventˢ{$}
const schema::Entity* VkEvent__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkEventˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkExtensionProperties:
// vulkan.VkExtensionProperties{$,Uint32}
const schema::Entity* VkExtensionProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkExtensionProperties",
        "",
        {
            schema::Field{"ExtensionName", new schema::Struct{ Char__256__A::StaticSchema()}},
            schema::Field{"SpecVersion", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkExtensionPropertiesˢ:
// vulkan.VkExtensionPropertiesˢ{$}
const schema::Entity* VkExtensionProperties__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkExtensionPropertiesˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkExtent2Dˢ:
// vulkan.VkExtent2Dˢ{$}
const schema::Entity* VkExtent2D__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkExtent2Dˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkExtent2Dᵖ:
// vulkan.VkExtent2Dᵖ{Uint64,Uint32}
const schema::Entity* VkExtent2D__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkExtent2Dᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkFenceCreateInfo:
// vulkan.VkFenceCreateInfo{Uint32,$,Uint32}
const schema::Entity* VkFenceCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFenceCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkFenceCreateFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkFenceCreateInfoˢ:
// vulkan.VkFenceCreateInfoˢ{$}
const schema::Entity* VkFenceCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFenceCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkFenceCreateInfoᵖ:
// vulkan.VkFenceCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkFenceCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFenceCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkFenceˢ:
// vulkan.VkFenceˢ{$}
const schema::Entity* VkFence__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFenceˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkFenceᶜᵖ:
// vulkan.VkFenceᶜᵖ{Uint64,Uint32}
const schema::Entity* VkFence__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFenceᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMappedMemoryRangeᶜᵖ:
// vulkan.VkMappedMemoryRangeᶜᵖ{Uint64,Uint32}
const schema::Entity* VkMappedMemoryRange__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMappedMemoryRangeᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkFlushMappedMemoryRanges:
// vulkan.VkFlushMappedMemoryRanges{[]?,Uint64,Uint32,$,Uint32}
void VkFlushMappedMemoryRanges::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint32(this->mMemoryRangeCount);
    e->Struct(this->mPMemoryRanges);
    e->Uint32(this->mResult);
}
const schema::Entity* VkFlushMappedMemoryRanges::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFlushMappedMemoryRanges",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"MemoryRangeCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PMemoryRanges", new schema::Struct{ VkMappedMemoryRange__CP::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkFormatProperties:
// vulkan.VkFormatProperties{Uint32,Uint32,Uint32}
const schema::Entity* VkFormatProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFormatProperties",
        "",
        {
            schema::Field{"LinearTilingFeatures", new schema::Primitive{"VkFormatFeatureFlags", schema::Primitive::Uint32}},
            schema::Field{"OptimalTilingFeatures", new schema::Primitive{"VkFormatFeatureFlags", schema::Primitive::Uint32}},
            schema::Field{"BufferFeatures", new schema::Primitive{"VkFormatFeatureFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkFormatPropertiesˢ:
// vulkan.VkFormatPropertiesˢ{$}
const schema::Entity* VkFormatProperties__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFormatPropertiesˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkFormatPropertiesᵖ:
// vulkan.VkFormatPropertiesᵖ{Uint64,Uint32}
const schema::Entity* VkFormatProperties__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFormatPropertiesᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageViewᶜᵖ:
// vulkan.VkImageViewᶜᵖ{Uint64,Uint32}
const schema::Entity* VkImageView__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageViewᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkFramebufferCreateInfo:
// vulkan.VkFramebufferCreateInfo{Uint32,$,Uint32,Uint64,Uint32,$,Uint32,Uint32,Uint32}
void VkFramebufferCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint64(this->mRenderPass);
    e->Uint32(this->mAttachmentCount);
    e->Struct(this->mPAttachments);
    e->Uint32(this->mWidth);
    e->Uint32(this->mHeight);
    e->Uint32(this->mLayers);
}
const schema::Entity* VkFramebufferCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFramebufferCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkFramebufferCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"RenderPass", new schema::Primitive{"VkRenderPass", schema::Primitive::Uint64}},
            schema::Field{"AttachmentCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PAttachments", new schema::Struct{ VkImageView__CP::StaticSchema()}},
            schema::Field{"Width", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Height", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Layers", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkFramebufferCreateInfoˢ:
// vulkan.VkFramebufferCreateInfoˢ{$}
const schema::Entity* VkFramebufferCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFramebufferCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkFramebufferCreateInfoᵖ:
// vulkan.VkFramebufferCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkFramebufferCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFramebufferCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkFramebufferˢ:
// vulkan.VkFramebufferˢ{$}
const schema::Entity* VkFramebuffer__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFramebufferˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkFreeCommandBuffers:
// vulkan.VkFreeCommandBuffers{[]?,Uint64,Uint64,Uint32,$}
void VkFreeCommandBuffers::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mCommandPool);
    e->Uint32(this->mCommandBufferCount);
    e->Struct(this->mPCommandBuffers);
}
const schema::Entity* VkFreeCommandBuffers::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFreeCommandBuffers",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"CommandPool", new schema::Primitive{"VkCommandPool", schema::Primitive::Uint64}},
            schema::Field{"CommandBufferCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PCommandBuffers", new schema::Struct{ VkCommandBuffer__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkFreeDescriptorSets:
// vulkan.VkFreeDescriptorSets{[]?,Uint64,Uint64,Uint32,$,Uint32}
void VkFreeDescriptorSets::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mDescriptorPool);
    e->Uint32(this->mDescriptorSetCount);
    e->Struct(this->mPDescriptorSets);
    e->Uint32(this->mResult);
}
const schema::Entity* VkFreeDescriptorSets::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFreeDescriptorSets",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"DescriptorPool", new schema::Primitive{"VkDescriptorPool", schema::Primitive::Uint64}},
            schema::Field{"DescriptorSetCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PDescriptorSets", new schema::Struct{ VkDescriptorSet__CP::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkFreeMemory:
// vulkan.VkFreeMemory{[]?,Uint64,Uint64,$}
void VkFreeMemory::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);
    e->Struct(this->mPAllocator);
}
const schema::Entity* VkFreeMemory::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkFreeMemory",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Memory", new schema::Primitive{"VkDeviceMemory", schema::Primitive::Uint64}},
            schema::Field{"PAllocator", new schema::Struct{ VkAllocationCallbacks__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkMemoryRequirementsᵖ:
// vulkan.VkMemoryRequirementsᵖ{Uint64,Uint32}
const schema::Entity* VkMemoryRequirements__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMemoryRequirementsᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetBufferMemoryRequirements:
// vulkan.VkGetBufferMemoryRequirements{[]?,Uint64,Uint64,$}
void VkGetBufferMemoryRequirements::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mBuffer);
    e->Struct(this->mPMemoryRequirements);
}
const schema::Entity* VkGetBufferMemoryRequirements::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetBufferMemoryRequirements",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Buffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"PMemoryRequirements", new schema::Struct{ VkMemoryRequirements__P::StaticSchema()}},
        },
    };
    return &entity;
}

// VkGetDeviceMemoryCommitment:
// vulkan.VkGetDeviceMemoryCommitment{[]?,Uint64,Uint64,$}
void VkGetDeviceMemoryCommitment::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);
    e->Struct(this->mPCommittedMemoryInBytes);
}
const schema::Entity* VkGetDeviceMemoryCommitment::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetDeviceMemoryCommitment",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Memory", new schema::Primitive{"VkDeviceMemory", schema::Primitive::Uint64}},
            schema::Field{"PCommittedMemoryInBytes", new schema::Struct{ VkDeviceSize__P::StaticSchema()}},
        },
    };
    return &entity;
}

// VkGetDeviceProcAddr:
// vulkan.VkGetDeviceProcAddr{[]?,Uint64,String,$}
void VkGetDeviceProcAddr::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->String(this->mPName);
    e->Struct(this->mResult);
}
const schema::Entity* VkGetDeviceProcAddr::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetDeviceProcAddr",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PName", new schema::Primitive{"string", schema::Primitive::String}},
            schema::Field{"Result", new schema::Struct{ PFN_vkVoidFunction::StaticSchema()}},
        },
    };
    return &entity;
}

// VkQueueᵖ:
// vulkan.VkQueueᵖ{Uint64,Uint32}
const schema::Entity* VkQueue__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkQueueᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetDeviceQueue:
// vulkan.VkGetDeviceQueue{[]?,Uint64,Uint32,Uint32,$}
void VkGetDeviceQueue::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint32(this->mQueueFamilyIndex);
    e->Uint32(this->mQueueIndex);
    e->Struct(this->mPQueue);
}
const schema::Entity* VkGetDeviceQueue::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetDeviceQueue",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"QueueFamilyIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"QueueIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PQueue", new schema::Struct{ VkQueue__P::StaticSchema()}},
        },
    };
    return &entity;
}

// VkGetDisplayModePropertiesKHR:
// vulkan.VkGetDisplayModePropertiesKHR{[]?,Uint64,Uint64,$,$,Uint32}
void VkGetDisplayModePropertiesKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Uint64(this->mDisplay);
    e->Struct(this->mPPropertyCount);
    e->Struct(this->mPProperties);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetDisplayModePropertiesKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetDisplayModePropertiesKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"Display", new schema::Primitive{"VkDisplayKHR", schema::Primitive::Uint64}},
            schema::Field{"PPropertyCount", new schema::Struct{ U32__P::StaticSchema()}},
            schema::Field{"PProperties", new schema::Struct{ VkDisplayModePropertiesKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetDisplayPlaneCapabilitiesKHR:
// vulkan.VkGetDisplayPlaneCapabilitiesKHR{[]?,Uint64,Uint64,Uint32,$,Uint32}
void VkGetDisplayPlaneCapabilitiesKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Uint64(this->mMode);
    e->Uint32(this->mPlaneIndex);
    e->Struct(this->mPCapabilities);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetDisplayPlaneCapabilitiesKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetDisplayPlaneCapabilitiesKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"Mode", new schema::Primitive{"VkDisplayModeKHR", schema::Primitive::Uint64}},
            schema::Field{"PlaneIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PCapabilities", new schema::Struct{ VkDisplayPlaneCapabilitiesKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetDisplayPlaneSupportedDisplaysKHR:
// vulkan.VkGetDisplayPlaneSupportedDisplaysKHR{[]?,Uint64,Uint32,$,$,Uint32}
void VkGetDisplayPlaneSupportedDisplaysKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Uint32(this->mPlaneIndex);
    e->Struct(this->mPDisplayCount);
    e->Struct(this->mPDisplays);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetDisplayPlaneSupportedDisplaysKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetDisplayPlaneSupportedDisplaysKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"PlaneIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PDisplayCount", new schema::Struct{ U32__P::StaticSchema()}},
            schema::Field{"PDisplays", new schema::Struct{ VkDisplayKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetEventStatus:
// vulkan.VkGetEventStatus{[]?,Uint64,Uint64,Uint32}
void VkGetEventStatus::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mEvent);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetEventStatus::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetEventStatus",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Event", new schema::Primitive{"VkEvent", schema::Primitive::Uint64}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetFenceStatus:
// vulkan.VkGetFenceStatus{[]?,Uint64,Uint64,Uint32}
void VkGetFenceStatus::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mFence);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetFenceStatus::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetFenceStatus",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Fence", new schema::Primitive{"VkFence", schema::Primitive::Uint64}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetImageMemoryRequirements:
// vulkan.VkGetImageMemoryRequirements{[]?,Uint64,Uint64,$}
void VkGetImageMemoryRequirements::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mImage);
    e->Struct(this->mPMemoryRequirements);
}
const schema::Entity* VkGetImageMemoryRequirements::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetImageMemoryRequirements",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Image", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"PMemoryRequirements", new schema::Struct{ VkMemoryRequirements__P::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSparseImageMemoryRequirementsᵖ:
// vulkan.VkSparseImageMemoryRequirementsᵖ{Uint64,Uint32}
const schema::Entity* VkSparseImageMemoryRequirements__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseImageMemoryRequirementsᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetImageSparseMemoryRequirements:
// vulkan.VkGetImageSparseMemoryRequirements{[]?,Uint64,Uint64,$,$}
void VkGetImageSparseMemoryRequirements::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mImage);
    e->Struct(this->mPSparseMemoryRequirementCount);
    e->Struct(this->mPSparseMemoryRequirements);
}
const schema::Entity* VkGetImageSparseMemoryRequirements::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetImageSparseMemoryRequirements",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Image", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"PSparseMemoryRequirementCount", new schema::Struct{ U32__P::StaticSchema()}},
            schema::Field{"PSparseMemoryRequirements", new schema::Struct{ VkSparseImageMemoryRequirements__P::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageSubresourceᶜᵖ:
// vulkan.VkImageSubresourceᶜᵖ{Uint64,Uint32}
const schema::Entity* VkImageSubresource__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageSubresourceᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSubresourceLayoutᵖ:
// vulkan.VkSubresourceLayoutᵖ{Uint64,Uint32}
const schema::Entity* VkSubresourceLayout__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSubresourceLayoutᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetImageSubresourceLayout:
// vulkan.VkGetImageSubresourceLayout{[]?,Uint64,Uint64,$,$}
void VkGetImageSubresourceLayout::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mImage);
    e->Struct(this->mPSubresource);
    e->Struct(this->mPLayout);
}
const schema::Entity* VkGetImageSubresourceLayout::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetImageSubresourceLayout",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Image", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"PSubresource", new schema::Struct{ VkImageSubresource__CP::StaticSchema()}},
            schema::Field{"PLayout", new schema::Struct{ VkSubresourceLayout__P::StaticSchema()}},
        },
    };
    return &entity;
}

// VkGetInstanceProcAddr:
// vulkan.VkGetInstanceProcAddr{[]?,Uint64,String,$}
void VkGetInstanceProcAddr::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mInstance);
    e->String(this->mPName);
    e->Struct(this->mResult);
}
const schema::Entity* VkGetInstanceProcAddr::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetInstanceProcAddr",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Instance", new schema::Primitive{"VkInstance", schema::Primitive::Uint64}},
            schema::Field{"PName", new schema::Primitive{"string", schema::Primitive::String}},
            schema::Field{"Result", new schema::Struct{ PFN_vkVoidFunction::StaticSchema()}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceDisplayPlanePropertiesKHR:
// vulkan.VkGetPhysicalDeviceDisplayPlanePropertiesKHR{[]?,Uint64,$,$,Uint32}
void VkGetPhysicalDeviceDisplayPlanePropertiesKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Struct(this->mPPropertyCount);
    e->Struct(this->mPProperties);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetPhysicalDeviceDisplayPlanePropertiesKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceDisplayPlanePropertiesKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"PPropertyCount", new schema::Struct{ U32__P::StaticSchema()}},
            schema::Field{"PProperties", new schema::Struct{ VkDisplayPlanePropertiesKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceDisplayPropertiesKHR:
// vulkan.VkGetPhysicalDeviceDisplayPropertiesKHR{[]?,Uint64,$,$,Uint32}
void VkGetPhysicalDeviceDisplayPropertiesKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Struct(this->mPPropertyCount);
    e->Struct(this->mPProperties);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetPhysicalDeviceDisplayPropertiesKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceDisplayPropertiesKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"PPropertyCount", new schema::Struct{ U32__P::StaticSchema()}},
            schema::Field{"PProperties", new schema::Struct{ VkDisplayPropertiesKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPhysicalDeviceFeaturesᵖ:
// vulkan.VkPhysicalDeviceFeaturesᵖ{Uint64,Uint32}
const schema::Entity* VkPhysicalDeviceFeatures__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPhysicalDeviceFeaturesᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceFeatures:
// vulkan.VkGetPhysicalDeviceFeatures{[]?,Uint64,$}
const schema::Entity* VkGetPhysicalDeviceFeatures::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceFeatures",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"PFeatures", new schema::Struct{ VkPhysicalDeviceFeatures__P::StaticSchema()}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceFormatProperties:
// vulkan.VkGetPhysicalDeviceFormatProperties{[]?,Uint64,Uint32,$}
void VkGetPhysicalDeviceFormatProperties::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Uint32(this->mFormat);
    e->Struct(this->mPFormatProperties);
}
const schema::Entity* VkGetPhysicalDeviceFormatProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceFormatProperties",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"Format", new schema::Primitive{"VkFormat", schema::Primitive::Uint32}},
            schema::Field{"PFormatProperties", new schema::Struct{ VkFormatProperties__P::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageFormatPropertiesᵖ:
// vulkan.VkImageFormatPropertiesᵖ{Uint64,Uint32}
const schema::Entity* VkImageFormatProperties__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageFormatPropertiesᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceImageFormatProperties:
// vulkan.VkGetPhysicalDeviceImageFormatProperties{[]?,Uint64,Uint32,Uint32,Uint32,Uint32,Uint32,$,Uint32}
void VkGetPhysicalDeviceImageFormatProperties::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Uint32(this->mFormat);
    e->Uint32(this->mType);
    e->Uint32(this->mTiling);
    e->Uint32(this->mUsage);
    e->Uint32(this->mFlags);
    e->Struct(this->mPImageFormatProperties);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetPhysicalDeviceImageFormatProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceImageFormatProperties",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"Format", new schema::Primitive{"VkFormat", schema::Primitive::Uint32}},
            schema::Field{"Type", new schema::Primitive{"VkImageType", schema::Primitive::Uint32}},
            schema::Field{"Tiling", new schema::Primitive{"VkImageTiling", schema::Primitive::Uint32}},
            schema::Field{"Usage", new schema::Primitive{"VkImageUsageFlags", schema::Primitive::Uint32}},
            schema::Field{"Flags", new schema::Primitive{"VkImageCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"PImageFormatProperties", new schema::Struct{ VkImageFormatProperties__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPhysicalDeviceMemoryPropertiesᵖ:
// vulkan.VkPhysicalDeviceMemoryPropertiesᵖ{Uint64,Uint32}
const schema::Entity* VkPhysicalDeviceMemoryProperties__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPhysicalDeviceMemoryPropertiesᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceMemoryProperties:
// vulkan.VkGetPhysicalDeviceMemoryProperties{[]?,Uint64,$}
const schema::Entity* VkGetPhysicalDeviceMemoryProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceMemoryProperties",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"PMemoryProperties", new schema::Struct{ VkPhysicalDeviceMemoryProperties__P::StaticSchema()}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceMirPresentationSupportKHR:
// vulkan.VkGetPhysicalDeviceMirPresentationSupportKHR{[]?,Uint64,Uint32,$,Uint32}
void VkGetPhysicalDeviceMirPresentationSupportKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Uint32(this->mQueueFamilyIndex);
    e->Struct(this->mConnection);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetPhysicalDeviceMirPresentationSupportKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceMirPresentationSupportKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"QueueFamilyIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Connection", new schema::Struct{ MirConnection__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPhysicalDevicePropertiesᵖ:
// vulkan.VkPhysicalDevicePropertiesᵖ{Uint64,Uint32}
const schema::Entity* VkPhysicalDeviceProperties__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPhysicalDevicePropertiesᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceProperties:
// vulkan.VkGetPhysicalDeviceProperties{[]?,Uint64,$}
const schema::Entity* VkGetPhysicalDeviceProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceProperties",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"PProperties", new schema::Struct{ VkPhysicalDeviceProperties__P::StaticSchema()}},
        },
    };
    return &entity;
}

// VkQueueFamilyPropertiesᵖ:
// vulkan.VkQueueFamilyPropertiesᵖ{Uint64,Uint32}
const schema::Entity* VkQueueFamilyProperties__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkQueueFamilyPropertiesᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceQueueFamilyProperties:
// vulkan.VkGetPhysicalDeviceQueueFamilyProperties{[]?,Uint64,$,$}
void VkGetPhysicalDeviceQueueFamilyProperties::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Struct(this->mPQueueFamilyPropertyCount);
    e->Struct(this->mPQueueFamilyProperties);
}
const schema::Entity* VkGetPhysicalDeviceQueueFamilyProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceQueueFamilyProperties",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"PQueueFamilyPropertyCount", new schema::Struct{ U32__P::StaticSchema()}},
            schema::Field{"PQueueFamilyProperties", new schema::Struct{ VkQueueFamilyProperties__P::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSparseImageFormatPropertiesᵖ:
// vulkan.VkSparseImageFormatPropertiesᵖ{Uint64,Uint32}
const schema::Entity* VkSparseImageFormatProperties__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseImageFormatPropertiesᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceSparseImageFormatProperties:
// vulkan.VkGetPhysicalDeviceSparseImageFormatProperties{[]?,Uint64,Uint32,Uint32,Uint32,Uint32,Uint32,$,$}
void VkGetPhysicalDeviceSparseImageFormatProperties::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Uint32(this->mFormat);
    e->Uint32(this->mType);
    e->Uint32(this->mSamples);
    e->Uint32(this->mUsage);
    e->Uint32(this->mTiling);
    e->Struct(this->mPPropertyCount);
    e->Struct(this->mPProperties);
}
const schema::Entity* VkGetPhysicalDeviceSparseImageFormatProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceSparseImageFormatProperties",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"Format", new schema::Primitive{"VkFormat", schema::Primitive::Uint32}},
            schema::Field{"Type", new schema::Primitive{"VkImageType", schema::Primitive::Uint32}},
            schema::Field{"Samples", new schema::Primitive{"VkSampleCountFlagBits", schema::Primitive::Uint32}},
            schema::Field{"Usage", new schema::Primitive{"VkImageUsageFlags", schema::Primitive::Uint32}},
            schema::Field{"Tiling", new schema::Primitive{"VkImageTiling", schema::Primitive::Uint32}},
            schema::Field{"PPropertyCount", new schema::Struct{ U32__P::StaticSchema()}},
            schema::Field{"PProperties", new schema::Struct{ VkSparseImageFormatProperties__P::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSurfaceCapabilitiesKHRᵖ:
// vulkan.VkSurfaceCapabilitiesKHRᵖ{Uint64,Uint32}
const schema::Entity* VkSurfaceCapabilitiesKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSurfaceCapabilitiesKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceSurfaceCapabilitiesKHR:
// vulkan.VkGetPhysicalDeviceSurfaceCapabilitiesKHR{[]?,Uint64,Uint64,$,Uint32}
void VkGetPhysicalDeviceSurfaceCapabilitiesKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Uint64(this->mSurface);
    e->Struct(this->mPSurfaceCapabilities);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetPhysicalDeviceSurfaceCapabilitiesKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceSurfaceCapabilitiesKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"Surface", new schema::Primitive{"VkSurfaceKHR", schema::Primitive::Uint64}},
            schema::Field{"PSurfaceCapabilities", new schema::Struct{ VkSurfaceCapabilitiesKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSurfaceFormatKHRᵖ:
// vulkan.VkSurfaceFormatKHRᵖ{Uint64,Uint32}
const schema::Entity* VkSurfaceFormatKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSurfaceFormatKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceSurfaceFormatsKHR:
// vulkan.VkGetPhysicalDeviceSurfaceFormatsKHR{[]?,Uint64,Uint64,$,$,Uint32}
void VkGetPhysicalDeviceSurfaceFormatsKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Uint64(this->mSurface);
    e->Struct(this->mPSurfaceFormatCount);
    e->Struct(this->mPSurfaceFormats);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetPhysicalDeviceSurfaceFormatsKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceSurfaceFormatsKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"Surface", new schema::Primitive{"VkSurfaceKHR", schema::Primitive::Uint64}},
            schema::Field{"PSurfaceFormatCount", new schema::Struct{ U32__P::StaticSchema()}},
            schema::Field{"PSurfaceFormats", new schema::Struct{ VkSurfaceFormatKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPresentModeKHRᵖ:
// vulkan.VkPresentModeKHRᵖ{Uint64,Uint32}
const schema::Entity* VkPresentModeKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPresentModeKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceSurfacePresentModesKHR:
// vulkan.VkGetPhysicalDeviceSurfacePresentModesKHR{[]?,Uint64,Uint64,$,$,Uint32}
void VkGetPhysicalDeviceSurfacePresentModesKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Uint64(this->mSurface);
    e->Struct(this->mPPresentModeCount);
    e->Struct(this->mPPresentModes);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetPhysicalDeviceSurfacePresentModesKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceSurfacePresentModesKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"Surface", new schema::Primitive{"VkSurfaceKHR", schema::Primitive::Uint64}},
            schema::Field{"PPresentModeCount", new schema::Struct{ U32__P::StaticSchema()}},
            schema::Field{"PPresentModes", new schema::Struct{ VkPresentModeKHR__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceSurfaceSupportKHR:
// vulkan.VkGetPhysicalDeviceSurfaceSupportKHR{[]?,Uint64,Uint32,Uint64,$,Uint32}
void VkGetPhysicalDeviceSurfaceSupportKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Uint32(this->mQueueFamilyIndex);
    e->Uint64(this->mSurface);
    e->Struct(this->mPSupported);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetPhysicalDeviceSurfaceSupportKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceSurfaceSupportKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"QueueFamilyIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Surface", new schema::Primitive{"VkSurfaceKHR", schema::Primitive::Uint64}},
            schema::Field{"PSupported", new schema::Struct{ VkBool32__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// Wl_displayᵖ:
// vulkan.Wl_displayᵖ{Uint64,Uint32}
const schema::Entity* Wl_display__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Wl_displayᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceWaylandPresentationSupportKHR:
// vulkan.VkGetPhysicalDeviceWaylandPresentationSupportKHR{[]?,Uint64,Uint32,$,Uint32}
void VkGetPhysicalDeviceWaylandPresentationSupportKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Uint32(this->mQueueFamilyIndex);
    e->Struct(this->mDisplay);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetPhysicalDeviceWaylandPresentationSupportKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceWaylandPresentationSupportKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"QueueFamilyIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Display", new schema::Struct{ Wl_display__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// Xcb_connection_tᵖ:
// vulkan.Xcb_connection_tᵖ{Uint64,Uint32}
const schema::Entity* Xcb_connection_t__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Xcb_connection_tᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceXcbPresentationSupportKHR:
// vulkan.VkGetPhysicalDeviceXcbPresentationSupportKHR{[]?,Uint64,Uint32,$,Uint32,Uint32}
void VkGetPhysicalDeviceXcbPresentationSupportKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Uint32(this->mQueueFamilyIndex);
    e->Struct(this->mConnection);
    e->Uint32(this->mVisualId);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetPhysicalDeviceXcbPresentationSupportKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceXcbPresentationSupportKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"QueueFamilyIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Connection", new schema::Struct{ Xcb_connection_t__P::StaticSchema()}},
            schema::Field{"VisualId", new schema::Primitive{"xcb_visualid_t", schema::Primitive::Uint32}},
            schema::Field{"Result", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetPhysicalDeviceXlibPresentationSupportKHR:
// vulkan.VkGetPhysicalDeviceXlibPresentationSupportKHR{[]?,Uint64,Uint32,$,Uint64,Uint32}
void VkGetPhysicalDeviceXlibPresentationSupportKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mPhysicalDevice);
    e->Uint32(this->mQueueFamilyIndex);
    e->Struct(this->mDpy);
    e->Uint64(this->mVisualID);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetPhysicalDeviceXlibPresentationSupportKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPhysicalDeviceXlibPresentationSupportKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"PhysicalDevice", new schema::Primitive{"VkPhysicalDevice", schema::Primitive::Uint64}},
            schema::Field{"QueueFamilyIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Dpy", new schema::Struct{ Display__P::StaticSchema()}},
            schema::Field{"VisualID", new schema::Primitive{"VisualID", schema::Primitive::Uint64}},
            schema::Field{"Result", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetPipelineCacheData:
// vulkan.VkGetPipelineCacheData{[]?,Uint64,Uint64,$,$,Uint32}
void VkGetPipelineCacheData::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mPipelineCache);
    e->Struct(this->mPDataSize);
    e->Struct(this->mPData);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetPipelineCacheData::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetPipelineCacheData",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"PipelineCache", new schema::Primitive{"VkPipelineCache", schema::Primitive::Uint64}},
            schema::Field{"PDataSize", new schema::Struct{ Size__P::StaticSchema()}},
            schema::Field{"PData", new schema::Struct{ Void__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetQueryPoolResults:
// vulkan.VkGetQueryPoolResults{[]?,Uint64,Uint64,Uint32,Uint32,Uint64,$,Uint64,Uint32,Uint32}
void VkGetQueryPoolResults::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mQueryPool);
    e->Uint32(this->mFirstQuery);
    e->Uint32(this->mQueryCount);
    e->Uint64(this->mDataSize);
    e->Struct(this->mPData);
    e->Uint64(this->mStride);
    e->Uint32(this->mFlags);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetQueryPoolResults::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetQueryPoolResults",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"QueryPool", new schema::Primitive{"VkQueryPool", schema::Primitive::Uint64}},
            schema::Field{"FirstQuery", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"QueryCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"DataSize", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"PData", new schema::Struct{ Void__P::StaticSchema()}},
            schema::Field{"Stride", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Flags", new schema::Primitive{"VkQueryResultFlags", schema::Primitive::Uint32}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetRenderAreaGranularity:
// vulkan.VkGetRenderAreaGranularity{[]?,Uint64,Uint64,$}
void VkGetRenderAreaGranularity::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mRenderPass);
    e->Struct(this->mPGranularity);
}
const schema::Entity* VkGetRenderAreaGranularity::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetRenderAreaGranularity",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"RenderPass", new schema::Primitive{"VkRenderPass", schema::Primitive::Uint64}},
            schema::Field{"PGranularity", new schema::Struct{ VkExtent2D__P::StaticSchema()}},
        },
    };
    return &entity;
}

// VkGetSwapchainGrallocUsageANDROID:
// vulkan.VkGetSwapchainGrallocUsageANDROID{[]?,Uint64,Uint32,Uint32,$,Uint32}
void VkGetSwapchainGrallocUsageANDROID::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint32(this->mFormat);
    e->Uint32(this->mImageUsage);
    e->Struct(this->mGrallocUsage);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetSwapchainGrallocUsageANDROID::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetSwapchainGrallocUsageANDROID",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Format", new schema::Primitive{"VkFormat", schema::Primitive::Uint32}},
            schema::Field{"ImageUsage", new schema::Primitive{"VkImageUsageFlags", schema::Primitive::Uint32}},
            schema::Field{"GrallocUsage", new schema::Struct{ Int__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGetSwapchainImagesKHR:
// vulkan.VkGetSwapchainImagesKHR{[]?,Uint64,Uint64,$,$,Uint32}
void VkGetSwapchainImagesKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mSwapchain);
    e->Struct(this->mPSwapchainImageCount);
    e->Struct(this->mPSwapchainImages);
    e->Uint32(this->mResult);
}
const schema::Entity* VkGetSwapchainImagesKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGetSwapchainImagesKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Swapchain", new schema::Primitive{"VkSwapchainKHR", schema::Primitive::Uint64}},
            schema::Field{"PSwapchainImageCount", new schema::Struct{ U32__P::StaticSchema()}},
            schema::Field{"PSwapchainImages", new schema::Struct{ VkImage__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineShaderStageCreateInfoᶜᵖ:
// vulkan.VkPipelineShaderStageCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineShaderStageCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineShaderStageCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineVertexInputStateCreateInfoᶜᵖ:
// vulkan.VkPipelineVertexInputStateCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineVertexInputStateCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineVertexInputStateCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineInputAssemblyStateCreateInfoᶜᵖ:
// vulkan.VkPipelineInputAssemblyStateCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineInputAssemblyStateCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineInputAssemblyStateCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineTessellationStateCreateInfoᶜᵖ:
// vulkan.VkPipelineTessellationStateCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineTessellationStateCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineTessellationStateCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineViewportStateCreateInfoᶜᵖ:
// vulkan.VkPipelineViewportStateCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineViewportStateCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineViewportStateCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineRasterizationStateCreateInfoᶜᵖ:
// vulkan.VkPipelineRasterizationStateCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineRasterizationStateCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineRasterizationStateCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineMultisampleStateCreateInfoᶜᵖ:
// vulkan.VkPipelineMultisampleStateCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineMultisampleStateCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineMultisampleStateCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineDepthStencilStateCreateInfoᶜᵖ:
// vulkan.VkPipelineDepthStencilStateCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineDepthStencilStateCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineDepthStencilStateCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineColorBlendStateCreateInfoᶜᵖ:
// vulkan.VkPipelineColorBlendStateCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineColorBlendStateCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineColorBlendStateCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineDynamicStateCreateInfoᶜᵖ:
// vulkan.VkPipelineDynamicStateCreateInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineDynamicStateCreateInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineDynamicStateCreateInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkGraphicsPipelineCreateInfo:
// vulkan.VkGraphicsPipelineCreateInfo{Uint32,$,Uint32,Uint32,$,$,$,$,$,$,$,$,$,$,Uint64,Uint64,Uint32,Uint64,Int32}
void VkGraphicsPipelineCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mStageCount);
    e->Struct(this->mPStages);
    e->Struct(this->mPVertexInputState);
    e->Struct(this->mPInputAssemblyState);
    e->Struct(this->mPTessellationState);
    e->Struct(this->mPViewportState);
    e->Struct(this->mPRasterizationState);
    e->Struct(this->mPMultisampleState);
    e->Struct(this->mPDepthStencilState);
    e->Struct(this->mPColorBlendState);
    e->Struct(this->mPDynamicState);
    e->Uint64(this->mLayout);
    e->Uint64(this->mRenderPass);
    e->Uint32(this->mSubpass);
    e->Uint64(this->mBasePipelineHandle);
    e->Int32(this->mBasePipelineIndex);
}
const schema::Entity* VkGraphicsPipelineCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGraphicsPipelineCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkPipelineCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"StageCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PStages", new schema::Struct{ VkPipelineShaderStageCreateInfo__CP::StaticSchema()}},
            schema::Field{"PVertexInputState", new schema::Struct{ VkPipelineVertexInputStateCreateInfo__CP::StaticSchema()}},
            schema::Field{"PInputAssemblyState", new schema::Struct{ VkPipelineInputAssemblyStateCreateInfo__CP::StaticSchema()}},
            schema::Field{"PTessellationState", new schema::Struct{ VkPipelineTessellationStateCreateInfo__CP::StaticSchema()}},
            schema::Field{"PViewportState", new schema::Struct{ VkPipelineViewportStateCreateInfo__CP::StaticSchema()}},
            schema::Field{"PRasterizationState", new schema::Struct{ VkPipelineRasterizationStateCreateInfo__CP::StaticSchema()}},
            schema::Field{"PMultisampleState", new schema::Struct{ VkPipelineMultisampleStateCreateInfo__CP::StaticSchema()}},
            schema::Field{"PDepthStencilState", new schema::Struct{ VkPipelineDepthStencilStateCreateInfo__CP::StaticSchema()}},
            schema::Field{"PColorBlendState", new schema::Struct{ VkPipelineColorBlendStateCreateInfo__CP::StaticSchema()}},
            schema::Field{"PDynamicState", new schema::Struct{ VkPipelineDynamicStateCreateInfo__CP::StaticSchema()}},
            schema::Field{"Layout", new schema::Primitive{"VkPipelineLayout", schema::Primitive::Uint64}},
            schema::Field{"RenderPass", new schema::Primitive{"VkRenderPass", schema::Primitive::Uint64}},
            schema::Field{"Subpass", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"BasePipelineHandle", new schema::Primitive{"VkPipeline", schema::Primitive::Uint64}},
            schema::Field{"BasePipelineIndex", new schema::Primitive{"int32", schema::Primitive::Int32}},
        },
    };
    return &entity;
}

// VkGraphicsPipelineCreateInfoˢ:
// vulkan.VkGraphicsPipelineCreateInfoˢ{$}
const schema::Entity* VkGraphicsPipelineCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGraphicsPipelineCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkGraphicsPipelineCreateInfoᵖ:
// vulkan.VkGraphicsPipelineCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkGraphicsPipelineCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkGraphicsPipelineCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkOffset3Dː2ᵃ:
// vulkan.VkOffset3Dː2ᵃ{[2]$}
const schema::Entity* VkOffset3D__2__A::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkOffset3Dː2ᵃ",
        "",
        {
            schema::Field{"Elements", new schema::Array{"", new schema::Struct{ VkOffset3D::StaticSchema()}, 2}},
        },
    };
    return &entity;
}

// VkImageBlit:
// vulkan.VkImageBlit{$,$,$,$}
void VkImageBlit::Encode(Encoder* e) const {
    e->Struct(this->mSrcSubresource);
    e->Struct(this->mSrcOffsets);
    e->Struct(this->mDstSubresource);
    e->Struct(this->mDstOffsets);
}
const schema::Entity* VkImageBlit::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageBlit",
        "",
        {
            schema::Field{"SrcSubresource", new schema::Struct{ VkImageSubresourceLayers::StaticSchema()}},
            schema::Field{"SrcOffsets", new schema::Struct{ VkOffset3D__2__A::StaticSchema()}},
            schema::Field{"DstSubresource", new schema::Struct{ VkImageSubresourceLayers::StaticSchema()}},
            schema::Field{"DstOffsets", new schema::Struct{ VkOffset3D__2__A::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageBlitˢ:
// vulkan.VkImageBlitˢ{$}
const schema::Entity* VkImageBlit__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageBlitˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageBlitᵖ:
// vulkan.VkImageBlitᵖ{Uint64,Uint32}
const schema::Entity* VkImageBlit__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageBlitᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageCopyˢ:
// vulkan.VkImageCopyˢ{$}
const schema::Entity* VkImageCopy__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageCopyˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageCopyᵖ:
// vulkan.VkImageCopyᵖ{Uint64,Uint32}
const schema::Entity* VkImageCopy__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageCopyᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageCreateInfo:
// vulkan.VkImageCreateInfo{Uint32,$,Uint32,Uint32,Uint32,$,Uint32,Uint32,Uint32,Uint32,Uint32,Uint32,Uint32,$,Uint32}
void VkImageCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mImageType);
    e->Uint32(this->mFormat);
    e->Struct(this->mExtent);
    e->Uint32(this->mMipLevels);
    e->Uint32(this->mArrayLayers);
    e->Uint32(this->mSamples);
    e->Uint32(this->mTiling);
    e->Uint32(this->mUsage);
    e->Uint32(this->mSharingMode);
    e->Uint32(this->mQueueFamilyIndexCount);
    e->Struct(this->mPQueueFamilyIndices);
    e->Uint32(this->mInitialLayout);
}
const schema::Entity* VkImageCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkImageCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"ImageType", new schema::Primitive{"VkImageType", schema::Primitive::Uint32}},
            schema::Field{"Format", new schema::Primitive{"VkFormat", schema::Primitive::Uint32}},
            schema::Field{"Extent", new schema::Struct{ VkExtent3D::StaticSchema()}},
            schema::Field{"MipLevels", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"ArrayLayers", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Samples", new schema::Primitive{"VkSampleCountFlagBits", schema::Primitive::Uint32}},
            schema::Field{"Tiling", new schema::Primitive{"VkImageTiling", schema::Primitive::Uint32}},
            schema::Field{"Usage", new schema::Primitive{"VkImageUsageFlags", schema::Primitive::Uint32}},
            schema::Field{"SharingMode", new schema::Primitive{"VkSharingMode", schema::Primitive::Uint32}},
            schema::Field{"QueueFamilyIndexCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PQueueFamilyIndices", new schema::Struct{ U32__CP::StaticSchema()}},
            schema::Field{"InitialLayout", new schema::Primitive{"VkImageLayout", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageCreateInfoˢ:
// vulkan.VkImageCreateInfoˢ{$}
const schema::Entity* VkImageCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageCreateInfoᵖ:
// vulkan.VkImageCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkImageCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageFormatProperties:
// vulkan.VkImageFormatProperties{$,Uint32,Uint32,Uint32,Uint64}
void VkImageFormatProperties::Encode(Encoder* e) const {
    e->Struct(this->mMaxExtent);
    e->Uint32(this->mMaxMipLevels);
    e->Uint32(this->mMaxArrayLayers);
    e->Uint32(this->mSampleCounts);
    e->Uint64(this->mMaxResourceSize);
}
const schema::Entity* VkImageFormatProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageFormatProperties",
        "",
        {
            schema::Field{"MaxExtent", new schema::Struct{ VkExtent3D::StaticSchema()}},
            schema::Field{"MaxMipLevels", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"MaxArrayLayers", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"SampleCounts", new schema::Primitive{"VkSampleCountFlags", schema::Primitive::Uint32}},
            schema::Field{"MaxResourceSize", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// VkImageFormatPropertiesˢ:
// vulkan.VkImageFormatPropertiesˢ{$}
const schema::Entity* VkImageFormatProperties__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageFormatPropertiesˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageMemoryBarrierˢ:
// vulkan.VkImageMemoryBarrierˢ{$}
const schema::Entity* VkImageMemoryBarrier__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageMemoryBarrierˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageMemoryBarrierᵖ:
// vulkan.VkImageMemoryBarrierᵖ{Uint64,Uint32}
const schema::Entity* VkImageMemoryBarrier__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageMemoryBarrierᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageResolve:
// vulkan.VkImageResolve{$,$,$,$,$}
void VkImageResolve::Encode(Encoder* e) const {
    e->Struct(this->mSrcSubresource);
    e->Struct(this->mSrcOffset);
    e->Struct(this->mDstSubresource);
    e->Struct(this->mDstOffset);
    e->Struct(this->mExtent);
}
const schema::Entity* VkImageResolve::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageResolve",
        "",
        {
            schema::Field{"SrcSubresource", new schema::Struct{ VkImageSubresourceLayers::StaticSchema()}},
            schema::Field{"SrcOffset", new schema::Struct{ VkOffset3D::StaticSchema()}},
            schema::Field{"DstSubresource", new schema::Struct{ VkImageSubresourceLayers::StaticSchema()}},
            schema::Field{"DstOffset", new schema::Struct{ VkOffset3D::StaticSchema()}},
            schema::Field{"Extent", new schema::Struct{ VkExtent3D::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageResolveˢ:
// vulkan.VkImageResolveˢ{$}
const schema::Entity* VkImageResolve__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageResolveˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageResolveᵖ:
// vulkan.VkImageResolveᵖ{Uint64,Uint32}
const schema::Entity* VkImageResolve__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageResolveᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageSubresource:
// vulkan.VkImageSubresource{Uint32,Uint32,Uint32}
const schema::Entity* VkImageSubresource::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageSubresource",
        "",
        {
            schema::Field{"AspectMask", new schema::Primitive{"VkImageAspectFlagBits", schema::Primitive::Uint32}},
            schema::Field{"MipLevel", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"ArrayLayer", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageSubresourceRangeˢ:
// vulkan.VkImageSubresourceRangeˢ{$}
const schema::Entity* VkImageSubresourceRange__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageSubresourceRangeˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageSubresourceRangeᵖ:
// vulkan.VkImageSubresourceRangeᵖ{Uint64,Uint32}
const schema::Entity* VkImageSubresourceRange__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageSubresourceRangeᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageSubresourceˢ:
// vulkan.VkImageSubresourceˢ{$}
const schema::Entity* VkImageSubresource__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageSubresourceˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageSubresourceᵖ:
// vulkan.VkImageSubresourceᵖ{Uint64,Uint32}
const schema::Entity* VkImageSubresource__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageSubresourceᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageViewCreateInfo:
// vulkan.VkImageViewCreateInfo{Uint32,$,Uint32,Uint64,Uint32,Uint32,$,$}
void VkImageViewCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint64(this->mImage);
    e->Uint32(this->mViewType);
    e->Uint32(this->mFormat);
    e->Struct(this->mComponents);
    e->Struct(this->mSubresourceRange);
}
const schema::Entity* VkImageViewCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageViewCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkImageViewCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"Image", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"ViewType", new schema::Primitive{"VkImageViewType", schema::Primitive::Uint32}},
            schema::Field{"Format", new schema::Primitive{"VkFormat", schema::Primitive::Uint32}},
            schema::Field{"Components", new schema::Struct{ VkComponentMapping::StaticSchema()}},
            schema::Field{"SubresourceRange", new schema::Struct{ VkImageSubresourceRange::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageViewCreateInfoˢ:
// vulkan.VkImageViewCreateInfoˢ{$}
const schema::Entity* VkImageViewCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageViewCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageViewCreateInfoᵖ:
// vulkan.VkImageViewCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkImageViewCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageViewCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkImageViewˢ:
// vulkan.VkImageViewˢ{$}
const schema::Entity* VkImageView__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageViewˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkImageˢ:
// vulkan.VkImageˢ{$}
const schema::Entity* VkImage__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkImageˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkInstanceCreateInfo:
// vulkan.VkInstanceCreateInfo{Uint32,$,Uint32,$,Uint32,$,Uint32,$}
void VkInstanceCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Struct(this->mPApplicationInfo);
    e->Uint32(this->mEnabledLayerCount);
    e->Struct(this->mPpEnabledLayerNames);
    e->Uint32(this->mEnabledExtensionCount);
    e->Struct(this->mPpEnabledExtensionNames);
}
const schema::Entity* VkInstanceCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkInstanceCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkInstanceCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"PApplicationInfo", new schema::Struct{ VkApplicationInfo__CP::StaticSchema()}},
            schema::Field{"EnabledLayerCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PpEnabledLayerNames", new schema::Struct{ Char__CP__CP::StaticSchema()}},
            schema::Field{"EnabledExtensionCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PpEnabledExtensionNames", new schema::Struct{ Char__CP__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkInstanceCreateInfoˢ:
// vulkan.VkInstanceCreateInfoˢ{$}
const schema::Entity* VkInstanceCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkInstanceCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkInstanceCreateInfoᵖ:
// vulkan.VkInstanceCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkInstanceCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkInstanceCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkInstanceˢ:
// vulkan.VkInstanceˢ{$}
const schema::Entity* VkInstance__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkInstanceˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkInvalidateMappedMemoryRanges:
// vulkan.VkInvalidateMappedMemoryRanges{[]?,Uint64,Uint32,$,Uint32}
void VkInvalidateMappedMemoryRanges::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint32(this->mMemoryRangeCount);
    e->Struct(this->mPMemoryRanges);
    e->Uint32(this->mResult);
}
const schema::Entity* VkInvalidateMappedMemoryRanges::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkInvalidateMappedMemoryRanges",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"MemoryRangeCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PMemoryRanges", new schema::Struct{ VkMappedMemoryRange__CP::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkLayerProperties:
// vulkan.VkLayerProperties{$,Uint32,Uint32,$}
void VkLayerProperties::Encode(Encoder* e) const {
    e->Struct(this->mLayerName);
    e->Uint32(this->mSpecVersion);
    e->Uint32(this->mImplementationVersion);
    e->Struct(this->mDescription);
}
const schema::Entity* VkLayerProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkLayerProperties",
        "",
        {
            schema::Field{"LayerName", new schema::Struct{ Char__256__A::StaticSchema()}},
            schema::Field{"SpecVersion", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"ImplementationVersion", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Description", new schema::Struct{ Char__256__A::StaticSchema()}},
        },
    };
    return &entity;
}

// VkLayerPropertiesˢ:
// vulkan.VkLayerPropertiesˢ{$}
const schema::Entity* VkLayerProperties__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkLayerPropertiesˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// Voidᵖᵖ:
// vulkan.Voidᵖᵖ{Uint64,Uint32}
const schema::Entity* Void__P__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Voidᵖᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMapMemory:
// vulkan.VkMapMemory{[]?,Uint64,Uint64,Uint64,Uint64,Uint32,$,Uint32}
void VkMapMemory::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);
    e->Uint64(this->mOffset);
    e->Uint64(this->mSize);
    e->Uint32(this->mFlags);
    e->Struct(this->mPpData);
    e->Uint32(this->mResult);
}
const schema::Entity* VkMapMemory::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMapMemory",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Memory", new schema::Primitive{"VkDeviceMemory", schema::Primitive::Uint64}},
            schema::Field{"Offset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Size", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Flags", new schema::Primitive{"VkMemoryMapFlags", schema::Primitive::Uint32}},
            schema::Field{"PpData", new schema::Struct{ Void__P__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMappedMemoryRange:
// vulkan.VkMappedMemoryRange{Uint32,$,Uint64,Uint64,Uint64}
void VkMappedMemoryRange::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint64(this->mMemory);
    e->Uint64(this->mOffset);
    e->Uint64(this->mSize);
}
const schema::Entity* VkMappedMemoryRange::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMappedMemoryRange",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Memory", new schema::Primitive{"VkDeviceMemory", schema::Primitive::Uint64}},
            schema::Field{"Offset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Size", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// VkMappedMemoryRangeˢ:
// vulkan.VkMappedMemoryRangeˢ{$}
const schema::Entity* VkMappedMemoryRange__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMappedMemoryRangeˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkMappedMemoryRangeᵖ:
// vulkan.VkMappedMemoryRangeᵖ{Uint64,Uint32}
const schema::Entity* VkMappedMemoryRange__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMappedMemoryRangeᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMemoryAllocateInfo:
// vulkan.VkMemoryAllocateInfo{Uint32,$,Uint64,Uint32}
void VkMemoryAllocateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint64(this->mAllocationSize);
    e->Uint32(this->mMemoryTypeIndex);
}
const schema::Entity* VkMemoryAllocateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMemoryAllocateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"AllocationSize", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"MemoryTypeIndex", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMemoryAllocateInfoˢ:
// vulkan.VkMemoryAllocateInfoˢ{$}
const schema::Entity* VkMemoryAllocateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMemoryAllocateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkMemoryAllocateInfoᵖ:
// vulkan.VkMemoryAllocateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkMemoryAllocateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMemoryAllocateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMemoryBarrier:
// vulkan.VkMemoryBarrier{Uint32,$,Uint32,Uint32}
void VkMemoryBarrier::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mSrcAccessMask);
    e->Uint32(this->mDstAccessMask);
}
const schema::Entity* VkMemoryBarrier::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMemoryBarrier",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"SrcAccessMask", new schema::Primitive{"VkAccessFlags", schema::Primitive::Uint32}},
            schema::Field{"DstAccessMask", new schema::Primitive{"VkAccessFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMemoryBarrierˢ:
// vulkan.VkMemoryBarrierˢ{$}
const schema::Entity* VkMemoryBarrier__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMemoryBarrierˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkMemoryBarrierᵖ:
// vulkan.VkMemoryBarrierᵖ{Uint64,Uint32}
const schema::Entity* VkMemoryBarrier__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMemoryBarrierᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMemoryRequirements:
// vulkan.VkMemoryRequirements{Uint64,Uint64,Uint32}
const schema::Entity* VkMemoryRequirements::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMemoryRequirements",
        "",
        {
            schema::Field{"Size", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Alignment", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"MemoryTypeBits", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMemoryRequirementsˢ:
// vulkan.VkMemoryRequirementsˢ{$}
const schema::Entity* VkMemoryRequirements__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMemoryRequirementsˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineCacheᶜᵖ:
// vulkan.VkPipelineCacheᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineCache__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineCacheᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMergePipelineCaches:
// vulkan.VkMergePipelineCaches{[]?,Uint64,Uint64,Uint32,$,Uint32}
void VkMergePipelineCaches::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mDstCache);
    e->Uint32(this->mSrcCacheCount);
    e->Struct(this->mPSrcCaches);
    e->Uint32(this->mResult);
}
const schema::Entity* VkMergePipelineCaches::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMergePipelineCaches",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"DstCache", new schema::Primitive{"VkPipelineCache", schema::Primitive::Uint64}},
            schema::Field{"SrcCacheCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PSrcCaches", new schema::Struct{ VkPipelineCache__CP::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkMirSurfaceCreateInfoKHRˢ:
// vulkan.VkMirSurfaceCreateInfoKHRˢ{$}
const schema::Entity* VkMirSurfaceCreateInfoKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMirSurfaceCreateInfoKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkMirSurfaceCreateInfoKHRᵖ:
// vulkan.VkMirSurfaceCreateInfoKHRᵖ{Uint64,Uint32}
const schema::Entity* VkMirSurfaceCreateInfoKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkMirSurfaceCreateInfoKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// buffer_handle_t:
// vulkan.buffer_handle_t{Uint64,Uint32}
const schema::Entity* buffer_handle_t::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "buffer_handle_t",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPhysicalDeviceFeaturesˢ:
// vulkan.VkPhysicalDeviceFeaturesˢ{$}
const schema::Entity* VkPhysicalDeviceFeatures__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPhysicalDeviceFeaturesˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

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

// VkPhysicalDeviceMemoryPropertiesˢ:
// vulkan.VkPhysicalDeviceMemoryPropertiesˢ{$}
const schema::Entity* VkPhysicalDeviceMemoryProperties__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPhysicalDeviceMemoryPropertiesˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPhysicalDeviceSparseProperties:
// vulkan.VkPhysicalDeviceSparseProperties{Uint32,Uint32,Uint32,Uint32,Uint32}
void VkPhysicalDeviceSparseProperties::Encode(Encoder* e) const {
    e->Uint32(this->mResidencyStandard2DBlockShape);
    e->Uint32(this->mResidencyStandard2DMultisampleBlockShape);
    e->Uint32(this->mResidencyStandard3DBlockShape);
    e->Uint32(this->mResidencyAlignedMipSize);
    e->Uint32(this->mResidencyNonResidentStrict);
}
const schema::Entity* VkPhysicalDeviceSparseProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPhysicalDeviceSparseProperties",
        "",
        {
            schema::Field{"ResidencyStandard2DBlockShape", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"ResidencyStandard2DMultisampleBlockShape", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"ResidencyStandard3DBlockShape", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"ResidencyAlignedMipSize", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"ResidencyNonResidentStrict", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPhysicalDeviceProperties:
// vulkan.VkPhysicalDeviceProperties{Uint32,Uint32,Uint32,Uint32,Uint32,$,$,$,$}
void VkPhysicalDeviceProperties::Encode(Encoder* e) const {
    e->Uint32(this->mApiVersion);
    e->Uint32(this->mDriverVersion);
    e->Uint32(this->mVendorID);
    e->Uint32(this->mDeviceID);
    e->Uint32(this->mDeviceType);
    e->Struct(this->mDeviceName);
    e->Struct(this->mPipelineCacheUUID);
    e->Struct(this->mLimits);
    e->Struct(this->mSparseProperties);
}
const schema::Entity* VkPhysicalDeviceProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPhysicalDeviceProperties",
        "",
        {
            schema::Field{"ApiVersion", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"DriverVersion", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"VendorID", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"DeviceID", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"DeviceType", new schema::Primitive{"VkPhysicalDeviceType", schema::Primitive::Uint32}},
            schema::Field{"DeviceName", new schema::Struct{ Char__256__A::StaticSchema()}},
            schema::Field{"PipelineCacheUUID", new schema::Struct{ U8__16__A::StaticSchema()}},
            schema::Field{"Limits", new schema::Struct{ VkPhysicalDeviceLimits::StaticSchema()}},
            schema::Field{"SparseProperties", new schema::Struct{ VkPhysicalDeviceSparseProperties::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPhysicalDevicePropertiesˢ:
// vulkan.VkPhysicalDevicePropertiesˢ{$}
const schema::Entity* VkPhysicalDeviceProperties__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPhysicalDevicePropertiesˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPhysicalDeviceˢ:
// vulkan.VkPhysicalDeviceˢ{$}
const schema::Entity* VkPhysicalDevice__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPhysicalDeviceˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineCacheCreateInfo:
// vulkan.VkPipelineCacheCreateInfo{Uint32,$,Uint32,Uint64,$}
void VkPipelineCacheCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint64(this->mInitialDataSize);
    e->Struct(this->mPInitialData);
}
const schema::Entity* VkPipelineCacheCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineCacheCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkPipelineCacheCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"InitialDataSize", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"PInitialData", new schema::Struct{ Void__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineCacheCreateInfoˢ:
// vulkan.VkPipelineCacheCreateInfoˢ{$}
const schema::Entity* VkPipelineCacheCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineCacheCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineCacheCreateInfoᵖ:
// vulkan.VkPipelineCacheCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineCacheCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineCacheCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineCacheˢ:
// vulkan.VkPipelineCacheˢ{$}
const schema::Entity* VkPipelineCache__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineCacheˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineColorBlendAttachmentState:
// vulkan.VkPipelineColorBlendAttachmentState{Uint32,Uint32,Uint32,Uint32,Uint32,Uint32,Uint32,Uint32}
void VkPipelineColorBlendAttachmentState::Encode(Encoder* e) const {
    e->Uint32(this->mBlendEnable);
    e->Uint32(this->mSrcColorBlendFactor);
    e->Uint32(this->mDstColorBlendFactor);
    e->Uint32(this->mColorBlendOp);
    e->Uint32(this->mSrcAlphaBlendFactor);
    e->Uint32(this->mDstAlphaBlendFactor);
    e->Uint32(this->mAlphaBlendOp);
    e->Uint32(this->mColorWriteMask);
}
const schema::Entity* VkPipelineColorBlendAttachmentState::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineColorBlendAttachmentState",
        "",
        {
            schema::Field{"BlendEnable", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"SrcColorBlendFactor", new schema::Primitive{"VkBlendFactor", schema::Primitive::Uint32}},
            schema::Field{"DstColorBlendFactor", new schema::Primitive{"VkBlendFactor", schema::Primitive::Uint32}},
            schema::Field{"ColorBlendOp", new schema::Primitive{"VkBlendOp", schema::Primitive::Uint32}},
            schema::Field{"SrcAlphaBlendFactor", new schema::Primitive{"VkBlendFactor", schema::Primitive::Uint32}},
            schema::Field{"DstAlphaBlendFactor", new schema::Primitive{"VkBlendFactor", schema::Primitive::Uint32}},
            schema::Field{"AlphaBlendOp", new schema::Primitive{"VkBlendOp", schema::Primitive::Uint32}},
            schema::Field{"ColorWriteMask", new schema::Primitive{"VkColorComponentFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineColorBlendAttachmentStateˢ:
// vulkan.VkPipelineColorBlendAttachmentStateˢ{$}
const schema::Entity* VkPipelineColorBlendAttachmentState__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineColorBlendAttachmentStateˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineColorBlendAttachmentStateᵖ:
// vulkan.VkPipelineColorBlendAttachmentStateᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineColorBlendAttachmentState__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineColorBlendAttachmentStateᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineColorBlendAttachmentStateᶜᵖ:
// vulkan.VkPipelineColorBlendAttachmentStateᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineColorBlendAttachmentState__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineColorBlendAttachmentStateᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineColorBlendStateCreateInfo:
// vulkan.VkPipelineColorBlendStateCreateInfo{Uint32,$,Uint32,Uint32,Uint32,Uint32,$,$}
void VkPipelineColorBlendStateCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mLogicOpEnable);
    e->Uint32(this->mLogicOp);
    e->Uint32(this->mAttachmentCount);
    e->Struct(this->mPAttachments);
    e->Struct(this->mBlendConstants);
}
const schema::Entity* VkPipelineColorBlendStateCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineColorBlendStateCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkPipelineColorBlendStateCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"LogicOpEnable", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"LogicOp", new schema::Primitive{"VkLogicOp", schema::Primitive::Uint32}},
            schema::Field{"AttachmentCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PAttachments", new schema::Struct{ VkPipelineColorBlendAttachmentState__CP::StaticSchema()}},
            schema::Field{"BlendConstants", new schema::Struct{ F32__4__A::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineColorBlendStateCreateInfoˢ:
// vulkan.VkPipelineColorBlendStateCreateInfoˢ{$}
const schema::Entity* VkPipelineColorBlendStateCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineColorBlendStateCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineColorBlendStateCreateInfoᵖ:
// vulkan.VkPipelineColorBlendStateCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineColorBlendStateCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineColorBlendStateCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkStencilOpState:
// vulkan.VkStencilOpState{Uint32,Uint32,Uint32,Uint32,Uint32,Uint32,Uint32}
void VkStencilOpState::Encode(Encoder* e) const {
    e->Uint32(this->mFailOp);
    e->Uint32(this->mPassOp);
    e->Uint32(this->mDepthFailOp);
    e->Uint32(this->mCompareOp);
    e->Uint32(this->mCompareMask);
    e->Uint32(this->mWriteMask);
    e->Uint32(this->mReference);
}
const schema::Entity* VkStencilOpState::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkStencilOpState",
        "",
        {
            schema::Field{"FailOp", new schema::Primitive{"VkStencilOp", schema::Primitive::Uint32}},
            schema::Field{"PassOp", new schema::Primitive{"VkStencilOp", schema::Primitive::Uint32}},
            schema::Field{"DepthFailOp", new schema::Primitive{"VkStencilOp", schema::Primitive::Uint32}},
            schema::Field{"CompareOp", new schema::Primitive{"VkCompareOp", schema::Primitive::Uint32}},
            schema::Field{"CompareMask", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"WriteMask", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Reference", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineDepthStencilStateCreateInfo:
// vulkan.VkPipelineDepthStencilStateCreateInfo{Uint32,$,Uint32,Uint32,Uint32,Uint32,Uint32,Uint32,$,$,Float32,Float32}
void VkPipelineDepthStencilStateCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mDepthTestEnable);
    e->Uint32(this->mDepthWriteEnable);
    e->Uint32(this->mDepthCompareOp);
    e->Uint32(this->mDepthBoundsTestEnable);
    e->Uint32(this->mStencilTestEnable);
    e->Struct(this->mFront);
    e->Struct(this->mBack);
    e->Float32(this->mMinDepthBounds);
    e->Float32(this->mMaxDepthBounds);
}
const schema::Entity* VkPipelineDepthStencilStateCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineDepthStencilStateCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkPipelineDepthStencilStateCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"DepthTestEnable", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"DepthWriteEnable", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"DepthCompareOp", new schema::Primitive{"VkCompareOp", schema::Primitive::Uint32}},
            schema::Field{"DepthBoundsTestEnable", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"StencilTestEnable", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"Front", new schema::Struct{ VkStencilOpState::StaticSchema()}},
            schema::Field{"Back", new schema::Struct{ VkStencilOpState::StaticSchema()}},
            schema::Field{"MinDepthBounds", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"MaxDepthBounds", new schema::Primitive{"float32", schema::Primitive::Float32}},
        },
    };
    return &entity;
}

// VkPipelineDepthStencilStateCreateInfoˢ:
// vulkan.VkPipelineDepthStencilStateCreateInfoˢ{$}
const schema::Entity* VkPipelineDepthStencilStateCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineDepthStencilStateCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineDepthStencilStateCreateInfoᵖ:
// vulkan.VkPipelineDepthStencilStateCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineDepthStencilStateCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineDepthStencilStateCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineDynamicStateCreateInfo:
// vulkan.VkPipelineDynamicStateCreateInfo{Uint32,$,Uint32,Uint32,$}
void VkPipelineDynamicStateCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mDynamicStateCount);
    e->Struct(this->mPDynamicStates);
}
const schema::Entity* VkPipelineDynamicStateCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineDynamicStateCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkPipelineDynamicStateCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"DynamicStateCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PDynamicStates", new schema::Struct{ VkDynamicState__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineDynamicStateCreateInfoˢ:
// vulkan.VkPipelineDynamicStateCreateInfoˢ{$}
const schema::Entity* VkPipelineDynamicStateCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineDynamicStateCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineDynamicStateCreateInfoᵖ:
// vulkan.VkPipelineDynamicStateCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineDynamicStateCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineDynamicStateCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineInputAssemblyStateCreateInfo:
// vulkan.VkPipelineInputAssemblyStateCreateInfo{Uint32,$,Uint32,Uint32,Uint32}
void VkPipelineInputAssemblyStateCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mTopology);
    e->Uint32(this->mPrimitiveRestartEnable);
}
const schema::Entity* VkPipelineInputAssemblyStateCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineInputAssemblyStateCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkPipelineInputAssemblyStateCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"Topology", new schema::Primitive{"VkPrimitiveTopology", schema::Primitive::Uint32}},
            schema::Field{"PrimitiveRestartEnable", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineInputAssemblyStateCreateInfoˢ:
// vulkan.VkPipelineInputAssemblyStateCreateInfoˢ{$}
const schema::Entity* VkPipelineInputAssemblyStateCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineInputAssemblyStateCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineInputAssemblyStateCreateInfoᵖ:
// vulkan.VkPipelineInputAssemblyStateCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineInputAssemblyStateCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineInputAssemblyStateCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPushConstantRangeᶜᵖ:
// vulkan.VkPushConstantRangeᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPushConstantRange__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPushConstantRangeᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineLayoutCreateInfo:
// vulkan.VkPipelineLayoutCreateInfo{Uint32,$,Uint32,Uint32,$,Uint32,$}
void VkPipelineLayoutCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mSetLayoutCount);
    e->Struct(this->mPSetLayouts);
    e->Uint32(this->mPushConstantRangeCount);
    e->Struct(this->mPPushConstantRanges);
}
const schema::Entity* VkPipelineLayoutCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineLayoutCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkPipelineLayoutCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"SetLayoutCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PSetLayouts", new schema::Struct{ VkDescriptorSetLayout__CP::StaticSchema()}},
            schema::Field{"PushConstantRangeCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PPushConstantRanges", new schema::Struct{ VkPushConstantRange__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineLayoutCreateInfoˢ:
// vulkan.VkPipelineLayoutCreateInfoˢ{$}
const schema::Entity* VkPipelineLayoutCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineLayoutCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineLayoutCreateInfoᵖ:
// vulkan.VkPipelineLayoutCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineLayoutCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineLayoutCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineLayoutˢ:
// vulkan.VkPipelineLayoutˢ{$}
const schema::Entity* VkPipelineLayout__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineLayoutˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSampleMaskᶜᵖ:
// vulkan.VkSampleMaskᶜᵖ{Uint64,Uint32}
const schema::Entity* VkSampleMask__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSampleMaskᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineMultisampleStateCreateInfo:
// vulkan.VkPipelineMultisampleStateCreateInfo{Uint32,$,Uint32,Uint32,Uint32,Float32,$,Uint32,Uint32}
void VkPipelineMultisampleStateCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mRasterizationSamples);
    e->Uint32(this->mSampleShadingEnable);
    e->Float32(this->mMinSampleShading);
    e->Struct(this->mPSampleMask);
    e->Uint32(this->mAlphaToCoverageEnable);
    e->Uint32(this->mAlphaToOneEnable);
}
const schema::Entity* VkPipelineMultisampleStateCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineMultisampleStateCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkPipelineMultisampleStateCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"RasterizationSamples", new schema::Primitive{"VkSampleCountFlagBits", schema::Primitive::Uint32}},
            schema::Field{"SampleShadingEnable", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"MinSampleShading", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"PSampleMask", new schema::Struct{ VkSampleMask__CP::StaticSchema()}},
            schema::Field{"AlphaToCoverageEnable", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"AlphaToOneEnable", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineMultisampleStateCreateInfoˢ:
// vulkan.VkPipelineMultisampleStateCreateInfoˢ{$}
const schema::Entity* VkPipelineMultisampleStateCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineMultisampleStateCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineMultisampleStateCreateInfoᵖ:
// vulkan.VkPipelineMultisampleStateCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineMultisampleStateCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineMultisampleStateCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineRasterizationStateCreateInfo:
// vulkan.VkPipelineRasterizationStateCreateInfo{Uint32,$,Uint32,Uint32,Uint32,Uint32,Uint32,Uint32,Uint32,Float32,Float32,Float32,Float32}
void VkPipelineRasterizationStateCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mDepthClampEnable);
    e->Uint32(this->mRasterizerDiscardEnable);
    e->Uint32(this->mPolygonMode);
    e->Uint32(this->mCullMode);
    e->Uint32(this->mFrontFace);
    e->Uint32(this->mDepthBiasEnable);
    e->Float32(this->mDepthBiasConstantFactor);
    e->Float32(this->mDepthBiasClamp);
    e->Float32(this->mDepthBiasSlopeFactor);
    e->Float32(this->mLineWidth);
}
const schema::Entity* VkPipelineRasterizationStateCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineRasterizationStateCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkPipelineRasterizationStateCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"DepthClampEnable", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"RasterizerDiscardEnable", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"PolygonMode", new schema::Primitive{"VkPolygonMode", schema::Primitive::Uint32}},
            schema::Field{"CullMode", new schema::Primitive{"VkCullModeFlags", schema::Primitive::Uint32}},
            schema::Field{"FrontFace", new schema::Primitive{"VkFrontFace", schema::Primitive::Uint32}},
            schema::Field{"DepthBiasEnable", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"DepthBiasConstantFactor", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"DepthBiasClamp", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"DepthBiasSlopeFactor", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"LineWidth", new schema::Primitive{"float32", schema::Primitive::Float32}},
        },
    };
    return &entity;
}

// VkPipelineRasterizationStateCreateInfoˢ:
// vulkan.VkPipelineRasterizationStateCreateInfoˢ{$}
const schema::Entity* VkPipelineRasterizationStateCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineRasterizationStateCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineRasterizationStateCreateInfoᵖ:
// vulkan.VkPipelineRasterizationStateCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineRasterizationStateCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineRasterizationStateCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineShaderStageCreateInfoˢ:
// vulkan.VkPipelineShaderStageCreateInfoˢ{$}
const schema::Entity* VkPipelineShaderStageCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineShaderStageCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineShaderStageCreateInfoᵖ:
// vulkan.VkPipelineShaderStageCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineShaderStageCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineShaderStageCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineStageFlagsˢ:
// vulkan.VkPipelineStageFlagsˢ{$}
const schema::Entity* VkPipelineStageFlags__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineStageFlagsˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineStageFlagsᵖ:
// vulkan.VkPipelineStageFlagsᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineStageFlags__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineStageFlagsᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineStageFlagsᶜᵖ:
// vulkan.VkPipelineStageFlagsᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineStageFlags__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineStageFlagsᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineTessellationStateCreateInfo:
// vulkan.VkPipelineTessellationStateCreateInfo{Uint32,$,Uint32,Uint32}
void VkPipelineTessellationStateCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mPatchControlPoints);
}
const schema::Entity* VkPipelineTessellationStateCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineTessellationStateCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkPipelineTessellationStateCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"PatchControlPoints", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineTessellationStateCreateInfoˢ:
// vulkan.VkPipelineTessellationStateCreateInfoˢ{$}
const schema::Entity* VkPipelineTessellationStateCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineTessellationStateCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineTessellationStateCreateInfoᵖ:
// vulkan.VkPipelineTessellationStateCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineTessellationStateCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineTessellationStateCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkVertexInputBindingDescriptionᶜᵖ:
// vulkan.VkVertexInputBindingDescriptionᶜᵖ{Uint64,Uint32}
const schema::Entity* VkVertexInputBindingDescription__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkVertexInputBindingDescriptionᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkVertexInputAttributeDescriptionᶜᵖ:
// vulkan.VkVertexInputAttributeDescriptionᶜᵖ{Uint64,Uint32}
const schema::Entity* VkVertexInputAttributeDescription__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkVertexInputAttributeDescriptionᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineVertexInputStateCreateInfo:
// vulkan.VkPipelineVertexInputStateCreateInfo{Uint32,$,Uint32,Uint32,$,Uint32,$}
void VkPipelineVertexInputStateCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mVertexBindingDescriptionCount);
    e->Struct(this->mPVertexBindingDescriptions);
    e->Uint32(this->mVertexAttributeDescriptionCount);
    e->Struct(this->mPVertexAttributeDescriptions);
}
const schema::Entity* VkPipelineVertexInputStateCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineVertexInputStateCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkPipelineVertexInputStateCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"VertexBindingDescriptionCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PVertexBindingDescriptions", new schema::Struct{ VkVertexInputBindingDescription__CP::StaticSchema()}},
            schema::Field{"VertexAttributeDescriptionCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PVertexAttributeDescriptions", new schema::Struct{ VkVertexInputAttributeDescription__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineVertexInputStateCreateInfoˢ:
// vulkan.VkPipelineVertexInputStateCreateInfoˢ{$}
const schema::Entity* VkPipelineVertexInputStateCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineVertexInputStateCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineVertexInputStateCreateInfoᵖ:
// vulkan.VkPipelineVertexInputStateCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineVertexInputStateCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineVertexInputStateCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineViewportStateCreateInfo:
// vulkan.VkPipelineViewportStateCreateInfo{Uint32,$,Uint32,Uint32,$,Uint32,$}
void VkPipelineViewportStateCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mViewportCount);
    e->Struct(this->mPViewports);
    e->Uint32(this->mScissorCount);
    e->Struct(this->mPScissors);
}
const schema::Entity* VkPipelineViewportStateCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineViewportStateCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkPipelineViewportStateCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"ViewportCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PViewports", new schema::Struct{ VkViewport__CP::StaticSchema()}},
            schema::Field{"ScissorCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PScissors", new schema::Struct{ VkRect2D__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineViewportStateCreateInfoˢ:
// vulkan.VkPipelineViewportStateCreateInfoˢ{$}
const schema::Entity* VkPipelineViewportStateCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineViewportStateCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPipelineViewportStateCreateInfoᵖ:
// vulkan.VkPipelineViewportStateCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkPipelineViewportStateCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineViewportStateCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPipelineˢ:
// vulkan.VkPipelineˢ{$}
const schema::Entity* VkPipeline__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPipelineˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSwapchainKHRᶜᵖ:
// vulkan.VkSwapchainKHRᶜᵖ{Uint64,Uint32}
const schema::Entity* VkSwapchainKHR__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSwapchainKHRᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkResultᵖ:
// vulkan.VkResultᵖ{Uint64,Uint32}
const schema::Entity* VkResult__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkResultᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPresentInfoKHR:
// vulkan.VkPresentInfoKHR{Uint32,$,Uint32,$,Uint32,$,$,$}
void VkPresentInfoKHR::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mWaitSemaphoreCount);
    e->Struct(this->mPWaitSemaphores);
    e->Uint32(this->mSwapchainCount);
    e->Struct(this->mPSwapchains);
    e->Struct(this->mPImageIndices);
    e->Struct(this->mPResults);
}
const schema::Entity* VkPresentInfoKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPresentInfoKHR",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"WaitSemaphoreCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PWaitSemaphores", new schema::Struct{ VkSemaphore__CP::StaticSchema()}},
            schema::Field{"SwapchainCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PSwapchains", new schema::Struct{ VkSwapchainKHR__CP::StaticSchema()}},
            schema::Field{"PImageIndices", new schema::Struct{ U32__CP::StaticSchema()}},
            schema::Field{"PResults", new schema::Struct{ VkResult__P::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPresentInfoKHRˢ:
// vulkan.VkPresentInfoKHRˢ{$}
const schema::Entity* VkPresentInfoKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPresentInfoKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPresentInfoKHRᵖ:
// vulkan.VkPresentInfoKHRᵖ{Uint64,Uint32}
const schema::Entity* VkPresentInfoKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPresentInfoKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPresentInfoKHRᶜᵖ:
// vulkan.VkPresentInfoKHRᶜᵖ{Uint64,Uint32}
const schema::Entity* VkPresentInfoKHR__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPresentInfoKHRᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPresentModeKHRˢ:
// vulkan.VkPresentModeKHRˢ{$}
const schema::Entity* VkPresentModeKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPresentModeKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPushConstantRange:
// vulkan.VkPushConstantRange{Uint32,Uint32,Uint32}
const schema::Entity* VkPushConstantRange::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPushConstantRange",
        "",
        {
            schema::Field{"StageFlags", new schema::Primitive{"VkShaderStageFlags", schema::Primitive::Uint32}},
            schema::Field{"Offset", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Size", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkPushConstantRangeˢ:
// vulkan.VkPushConstantRangeˢ{$}
const schema::Entity* VkPushConstantRange__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPushConstantRangeˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkPushConstantRangeᵖ:
// vulkan.VkPushConstantRangeᵖ{Uint64,Uint32}
const schema::Entity* VkPushConstantRange__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkPushConstantRangeᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkQueryPoolCreateInfo:
// vulkan.VkQueryPoolCreateInfo{Uint32,$,Uint32,Uint32,Uint32,Uint32}
void VkQueryPoolCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mQueryType);
    e->Uint32(this->mQueryCount);
    e->Uint32(this->mPipelineStatistics);
}
const schema::Entity* VkQueryPoolCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkQueryPoolCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkQueryPoolCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"QueryType", new schema::Primitive{"VkQueryType", schema::Primitive::Uint32}},
            schema::Field{"QueryCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PipelineStatistics", new schema::Primitive{"VkQueryPipelineStatisticFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkQueryPoolCreateInfoˢ:
// vulkan.VkQueryPoolCreateInfoˢ{$}
const schema::Entity* VkQueryPoolCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkQueryPoolCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkQueryPoolCreateInfoᵖ:
// vulkan.VkQueryPoolCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkQueryPoolCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkQueryPoolCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkQueryPoolˢ:
// vulkan.VkQueryPoolˢ{$}
const schema::Entity* VkQueryPool__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkQueryPoolˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkQueueBindSparse:
// vulkan.VkQueueBindSparse{[]?,Uint64,Uint32,$,Uint64,Uint32}
void VkQueueBindSparse::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mQueue);
    e->Uint32(this->mBindInfoCount);
    e->Struct(this->mPBindInfo);
    e->Uint64(this->mFence);
    e->Uint32(this->mResult);
}
const schema::Entity* VkQueueBindSparse::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkQueueBindSparse",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Queue", new schema::Primitive{"VkQueue", schema::Primitive::Uint64}},
            schema::Field{"BindInfoCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PBindInfo", new schema::Struct{ VkBindSparseInfo__CP::StaticSchema()}},
            schema::Field{"Fence", new schema::Primitive{"VkFence", schema::Primitive::Uint64}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkQueueFamilyProperties:
// vulkan.VkQueueFamilyProperties{Uint32,Uint32,Uint32,$}
void VkQueueFamilyProperties::Encode(Encoder* e) const {
    e->Uint32(this->mQueueFlags);
    e->Uint32(this->mQueueCount);
    e->Uint32(this->mTimestampValidBits);
    e->Struct(this->mMinImageTransferGranularity);
}
const schema::Entity* VkQueueFamilyProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkQueueFamilyProperties",
        "",
        {
            schema::Field{"QueueFlags", new schema::Primitive{"VkQueueFlags", schema::Primitive::Uint32}},
            schema::Field{"QueueCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"TimestampValidBits", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"MinImageTransferGranularity", new schema::Struct{ VkExtent3D::StaticSchema()}},
        },
    };
    return &entity;
}

// VkQueueFamilyPropertiesˢ:
// vulkan.VkQueueFamilyPropertiesˢ{$}
const schema::Entity* VkQueueFamilyProperties__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkQueueFamilyPropertiesˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkQueuePresentKHR:
// vulkan.VkQueuePresentKHR{[]?,Uint64,$,Uint32}
void VkQueuePresentKHR::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mQueue);
    e->Struct(this->mPPresentInfo);
    e->Uint32(this->mResult);
}
const schema::Entity* VkQueuePresentKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkQueuePresentKHR",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Queue", new schema::Primitive{"VkQueue", schema::Primitive::Uint64}},
            schema::Field{"PPresentInfo", new schema::Struct{ VkPresentInfoKHR__CP::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkQueueSignalReleaseImageANDROID:
// vulkan.VkQueueSignalReleaseImageANDROID{[]?,Uint64,Uint32,$,Uint64,$,Uint32}
void VkQueueSignalReleaseImageANDROID::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mQueue);
    e->Uint32(this->mWaitSemaphoreCount);
    e->Struct(this->mPWaitSemaphores);
    e->Uint64(this->mImage);
    e->Struct(this->mPNativeFenceFd);
    e->Uint32(this->mResult);
}
const schema::Entity* VkQueueSignalReleaseImageANDROID::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkQueueSignalReleaseImageANDROID",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Queue", new schema::Primitive{"VkQueue", schema::Primitive::Uint64}},
            schema::Field{"WaitSemaphoreCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PWaitSemaphores", new schema::Struct{ VkSemaphore__CP::StaticSchema()}},
            schema::Field{"Image", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"PNativeFenceFd", new schema::Struct{ Int__P::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSubmitInfoᶜᵖ:
// vulkan.VkSubmitInfoᶜᵖ{Uint64,Uint32}
const schema::Entity* VkSubmitInfo__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSubmitInfoᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkQueueSubmit:
// vulkan.VkQueueSubmit{[]?,Uint64,Uint32,$,Uint64,Uint32}
void VkQueueSubmit::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mQueue);
    e->Uint32(this->mSubmitCount);
    e->Struct(this->mPSubmits);
    e->Uint64(this->mFence);
    e->Uint32(this->mResult);
}
const schema::Entity* VkQueueSubmit::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkQueueSubmit",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Queue", new schema::Primitive{"VkQueue", schema::Primitive::Uint64}},
            schema::Field{"SubmitCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PSubmits", new schema::Struct{ VkSubmitInfo__CP::StaticSchema()}},
            schema::Field{"Fence", new schema::Primitive{"VkFence", schema::Primitive::Uint64}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkQueueWaitIdle:
// vulkan.VkQueueWaitIdle{[]?,Uint64,Uint32}
const schema::Entity* VkQueueWaitIdle::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkQueueWaitIdle",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Queue", new schema::Primitive{"VkQueue", schema::Primitive::Uint64}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkQueueˢ:
// vulkan.VkQueueˢ{$}
const schema::Entity* VkQueue__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkQueueˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkRect2Dˢ:
// vulkan.VkRect2Dˢ{$}
const schema::Entity* VkRect2D__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkRect2Dˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkRect2Dᵖ:
// vulkan.VkRect2Dᵖ{Uint64,Uint32}
const schema::Entity* VkRect2D__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkRect2Dᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkRenderPassBeginInfo:
// vulkan.VkRenderPassBeginInfo{Uint32,$,Uint64,Uint64,$,Uint32,$}
void VkRenderPassBeginInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint64(this->mRenderPass);
    e->Uint64(this->mFramebuffer);
    e->Struct(this->mRenderArea);
    e->Uint32(this->mClearValueCount);
    e->Struct(this->mPClearValues);
}
const schema::Entity* VkRenderPassBeginInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkRenderPassBeginInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"RenderPass", new schema::Primitive{"VkRenderPass", schema::Primitive::Uint64}},
            schema::Field{"Framebuffer", new schema::Primitive{"VkFramebuffer", schema::Primitive::Uint64}},
            schema::Field{"RenderArea", new schema::Struct{ VkRect2D::StaticSchema()}},
            schema::Field{"ClearValueCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PClearValues", new schema::Struct{ VkClearValue__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkRenderPassBeginInfoˢ:
// vulkan.VkRenderPassBeginInfoˢ{$}
const schema::Entity* VkRenderPassBeginInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkRenderPassBeginInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkRenderPassBeginInfoᵖ:
// vulkan.VkRenderPassBeginInfoᵖ{Uint64,Uint32}
const schema::Entity* VkRenderPassBeginInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkRenderPassBeginInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSubpassDescriptionᶜᵖ:
// vulkan.VkSubpassDescriptionᶜᵖ{Uint64,Uint32}
const schema::Entity* VkSubpassDescription__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSubpassDescriptionᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSubpassDependencyᶜᵖ:
// vulkan.VkSubpassDependencyᶜᵖ{Uint64,Uint32}
const schema::Entity* VkSubpassDependency__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSubpassDependencyᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkRenderPassCreateInfo:
// vulkan.VkRenderPassCreateInfo{Uint32,$,Uint32,Uint32,$,Uint32,$,Uint32,$}
void VkRenderPassCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mAttachmentCount);
    e->Struct(this->mPAttachments);
    e->Uint32(this->mSubpassCount);
    e->Struct(this->mPSubpasses);
    e->Uint32(this->mDependencyCount);
    e->Struct(this->mPDependencies);
}
const schema::Entity* VkRenderPassCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkRenderPassCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkRenderPassCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"AttachmentCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PAttachments", new schema::Struct{ VkAttachmentDescription__CP::StaticSchema()}},
            schema::Field{"SubpassCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PSubpasses", new schema::Struct{ VkSubpassDescription__CP::StaticSchema()}},
            schema::Field{"DependencyCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PDependencies", new schema::Struct{ VkSubpassDependency__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkRenderPassCreateInfoˢ:
// vulkan.VkRenderPassCreateInfoˢ{$}
const schema::Entity* VkRenderPassCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkRenderPassCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkRenderPassCreateInfoᵖ:
// vulkan.VkRenderPassCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkRenderPassCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkRenderPassCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkRenderPassˢ:
// vulkan.VkRenderPassˢ{$}
const schema::Entity* VkRenderPass__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkRenderPassˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkResetCommandBuffer:
// vulkan.VkResetCommandBuffer{[]?,Uint64,Uint32,Uint32}
void VkResetCommandBuffer::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mCommandBuffer);
    e->Uint32(this->mFlags);
    e->Uint32(this->mResult);
}
const schema::Entity* VkResetCommandBuffer::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkResetCommandBuffer",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"CommandBuffer", new schema::Primitive{"VkCommandBuffer", schema::Primitive::Uint64}},
            schema::Field{"Flags", new schema::Primitive{"VkCommandBufferResetFlags", schema::Primitive::Uint32}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkResetCommandPool:
// vulkan.VkResetCommandPool{[]?,Uint64,Uint64,Uint32,Uint32}
void VkResetCommandPool::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mCommandPool);
    e->Uint32(this->mFlags);
    e->Uint32(this->mResult);
}
const schema::Entity* VkResetCommandPool::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkResetCommandPool",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"CommandPool", new schema::Primitive{"VkCommandPool", schema::Primitive::Uint64}},
            schema::Field{"Flags", new schema::Primitive{"VkCommandPoolResetFlags", schema::Primitive::Uint32}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkResetDescriptorPool:
// vulkan.VkResetDescriptorPool{[]?,Uint64,Uint64,Uint32,Uint32}
void VkResetDescriptorPool::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mDescriptorPool);
    e->Uint32(this->mFlags);
    e->Uint32(this->mResult);
}
const schema::Entity* VkResetDescriptorPool::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkResetDescriptorPool",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"DescriptorPool", new schema::Primitive{"VkDescriptorPool", schema::Primitive::Uint64}},
            schema::Field{"Flags", new schema::Primitive{"VkDescriptorPoolResetFlags", schema::Primitive::Uint32}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkResetEvent:
// vulkan.VkResetEvent{[]?,Uint64,Uint64,Uint32}
void VkResetEvent::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mEvent);
    e->Uint32(this->mResult);
}
const schema::Entity* VkResetEvent::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkResetEvent",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Event", new schema::Primitive{"VkEvent", schema::Primitive::Uint64}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkResetFences:
// vulkan.VkResetFences{[]?,Uint64,Uint32,$,Uint32}
void VkResetFences::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint32(this->mFenceCount);
    e->Struct(this->mPFences);
    e->Uint32(this->mResult);
}
const schema::Entity* VkResetFences::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkResetFences",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"FenceCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PFences", new schema::Struct{ VkFence__CP::StaticSchema()}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkResultˢ:
// vulkan.VkResultˢ{$}
const schema::Entity* VkResult__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkResultˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSampleMaskˢ:
// vulkan.VkSampleMaskˢ{$}
const schema::Entity* VkSampleMask__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSampleMaskˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSampleMaskᵖ:
// vulkan.VkSampleMaskᵖ{Uint64,Uint32}
const schema::Entity* VkSampleMask__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSampleMaskᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSamplerCreateInfo:
// vulkan.VkSamplerCreateInfo{Uint32,$,Uint32,Uint32,Uint32,Uint32,Uint32,Uint32,Uint32,Float32,Uint32,Float32,Uint32,Uint32,Float32,Float32,Uint32,Uint32}
void VkSamplerCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint32(this->mMagFilter);
    e->Uint32(this->mMinFilter);
    e->Uint32(this->mMipmapMode);
    e->Uint32(this->mAddressModeU);
    e->Uint32(this->mAddressModeV);
    e->Uint32(this->mAddressModeW);
    e->Float32(this->mMipLodBias);
    e->Uint32(this->mAnisotropyEnable);
    e->Float32(this->mMaxAnisotropy);
    e->Uint32(this->mCompareEnable);
    e->Uint32(this->mCompareOp);
    e->Float32(this->mMinLod);
    e->Float32(this->mMaxLod);
    e->Uint32(this->mBorderColor);
    e->Uint32(this->mUnnormalizedCoordinates);
}
const schema::Entity* VkSamplerCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSamplerCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkSamplerCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"MagFilter", new schema::Primitive{"VkFilter", schema::Primitive::Uint32}},
            schema::Field{"MinFilter", new schema::Primitive{"VkFilter", schema::Primitive::Uint32}},
            schema::Field{"MipmapMode", new schema::Primitive{"VkSamplerMipmapMode", schema::Primitive::Uint32}},
            schema::Field{"AddressModeU", new schema::Primitive{"VkSamplerAddressMode", schema::Primitive::Uint32}},
            schema::Field{"AddressModeV", new schema::Primitive{"VkSamplerAddressMode", schema::Primitive::Uint32}},
            schema::Field{"AddressModeW", new schema::Primitive{"VkSamplerAddressMode", schema::Primitive::Uint32}},
            schema::Field{"MipLodBias", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"AnisotropyEnable", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"MaxAnisotropy", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"CompareEnable", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"CompareOp", new schema::Primitive{"VkCompareOp", schema::Primitive::Uint32}},
            schema::Field{"MinLod", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"MaxLod", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"BorderColor", new schema::Primitive{"VkBorderColor", schema::Primitive::Uint32}},
            schema::Field{"UnnormalizedCoordinates", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSamplerCreateInfoˢ:
// vulkan.VkSamplerCreateInfoˢ{$}
const schema::Entity* VkSamplerCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSamplerCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSamplerCreateInfoᵖ:
// vulkan.VkSamplerCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkSamplerCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSamplerCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSamplerˢ:
// vulkan.VkSamplerˢ{$}
const schema::Entity* VkSampler__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSamplerˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSemaphoreCreateInfo:
// vulkan.VkSemaphoreCreateInfo{Uint32,$,Uint32}
const schema::Entity* VkSemaphoreCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSemaphoreCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkSemaphoreCreateFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSemaphoreCreateInfoˢ:
// vulkan.VkSemaphoreCreateInfoˢ{$}
const schema::Entity* VkSemaphoreCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSemaphoreCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSemaphoreCreateInfoᵖ:
// vulkan.VkSemaphoreCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkSemaphoreCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSemaphoreCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSemaphoreˢ:
// vulkan.VkSemaphoreˢ{$}
const schema::Entity* VkSemaphore__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSemaphoreˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSetEvent:
// vulkan.VkSetEvent{[]?,Uint64,Uint64,Uint32}
void VkSetEvent::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint64(this->mEvent);
    e->Uint32(this->mResult);
}
const schema::Entity* VkSetEvent::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSetEvent",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Event", new schema::Primitive{"VkEvent", schema::Primitive::Uint64}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkShaderModuleCreateInfo:
// vulkan.VkShaderModuleCreateInfo{Uint32,$,Uint32,Uint64,$}
void VkShaderModuleCreateInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint64(this->mCodeSize);
    e->Struct(this->mPCode);
}
const schema::Entity* VkShaderModuleCreateInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkShaderModuleCreateInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkShaderModuleCreateFlags", schema::Primitive::Uint32}},
            schema::Field{"CodeSize", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"PCode", new schema::Struct{ U32__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkShaderModuleCreateInfoˢ:
// vulkan.VkShaderModuleCreateInfoˢ{$}
const schema::Entity* VkShaderModuleCreateInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkShaderModuleCreateInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkShaderModuleCreateInfoᵖ:
// vulkan.VkShaderModuleCreateInfoᵖ{Uint64,Uint32}
const schema::Entity* VkShaderModuleCreateInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkShaderModuleCreateInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkShaderModuleˢ:
// vulkan.VkShaderModuleˢ{$}
const schema::Entity* VkShaderModule__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkShaderModuleˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSparseMemoryBindᶜᵖ:
// vulkan.VkSparseMemoryBindᶜᵖ{Uint64,Uint32}
const schema::Entity* VkSparseMemoryBind__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseMemoryBindᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSparseBufferMemoryBindInfo:
// vulkan.VkSparseBufferMemoryBindInfo{Uint64,Uint32,$}
const schema::Entity* VkSparseBufferMemoryBindInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseBufferMemoryBindInfo",
        "",
        {
            schema::Field{"Buffer", new schema::Primitive{"VkBuffer", schema::Primitive::Uint64}},
            schema::Field{"BindCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PBinds", new schema::Struct{ VkSparseMemoryBind__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSparseBufferMemoryBindInfoˢ:
// vulkan.VkSparseBufferMemoryBindInfoˢ{$}
const schema::Entity* VkSparseBufferMemoryBindInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseBufferMemoryBindInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSparseBufferMemoryBindInfoᵖ:
// vulkan.VkSparseBufferMemoryBindInfoᵖ{Uint64,Uint32}
const schema::Entity* VkSparseBufferMemoryBindInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseBufferMemoryBindInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSparseImageFormatProperties:
// vulkan.VkSparseImageFormatProperties{Uint32,$,Uint32}
const schema::Entity* VkSparseImageFormatProperties::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseImageFormatProperties",
        "",
        {
            schema::Field{"AspectMask", new schema::Primitive{"VkImageAspectFlagBits", schema::Primitive::Uint32}},
            schema::Field{"ImageGranularity", new schema::Struct{ VkExtent3D::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkSparseImageFormatFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSparseImageFormatPropertiesˢ:
// vulkan.VkSparseImageFormatPropertiesˢ{$}
const schema::Entity* VkSparseImageFormatProperties__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseImageFormatPropertiesˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSparseImageMemoryBind:
// vulkan.VkSparseImageMemoryBind{$,$,$,Uint64,Uint64,Uint32}
void VkSparseImageMemoryBind::Encode(Encoder* e) const {
    e->Struct(this->mSubresource);
    e->Struct(this->mOffset);
    e->Struct(this->mExtent);
    e->Uint64(this->mMemory);
    e->Uint64(this->mMemoryOffset);
    e->Uint32(this->mFlags);
}
const schema::Entity* VkSparseImageMemoryBind::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseImageMemoryBind",
        "",
        {
            schema::Field{"Subresource", new schema::Struct{ VkImageSubresource::StaticSchema()}},
            schema::Field{"Offset", new schema::Struct{ VkOffset3D::StaticSchema()}},
            schema::Field{"Extent", new schema::Struct{ VkExtent3D::StaticSchema()}},
            schema::Field{"Memory", new schema::Primitive{"VkDeviceMemory", schema::Primitive::Uint64}},
            schema::Field{"MemoryOffset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Flags", new schema::Primitive{"VkSparseMemoryBindFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSparseImageMemoryBindInfo:
// vulkan.VkSparseImageMemoryBindInfo{Uint64,Uint32,$}
const schema::Entity* VkSparseImageMemoryBindInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseImageMemoryBindInfo",
        "",
        {
            schema::Field{"Image", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"BindCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PBinds", new schema::Struct{ VkSparseMemoryBind__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSparseImageMemoryBindInfoˢ:
// vulkan.VkSparseImageMemoryBindInfoˢ{$}
const schema::Entity* VkSparseImageMemoryBindInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseImageMemoryBindInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSparseImageMemoryBindInfoᵖ:
// vulkan.VkSparseImageMemoryBindInfoᵖ{Uint64,Uint32}
const schema::Entity* VkSparseImageMemoryBindInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseImageMemoryBindInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSparseImageMemoryRequirements:
// vulkan.VkSparseImageMemoryRequirements{$,Uint32,Uint64,Uint64,Uint64}
void VkSparseImageMemoryRequirements::Encode(Encoder* e) const {
    e->Struct(this->mFormatProperties);
    e->Uint32(this->mImageMipTailFirstLod);
    e->Uint64(this->mImageMipTailSize);
    e->Uint64(this->mImageMipTailOffset);
    e->Uint64(this->mImageMipTailStride);
}
const schema::Entity* VkSparseImageMemoryRequirements::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseImageMemoryRequirements",
        "",
        {
            schema::Field{"FormatProperties", new schema::Struct{ VkSparseImageFormatProperties::StaticSchema()}},
            schema::Field{"ImageMipTailFirstLod", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"ImageMipTailSize", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"ImageMipTailOffset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"ImageMipTailStride", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// VkSparseImageMemoryRequirementsˢ:
// vulkan.VkSparseImageMemoryRequirementsˢ{$}
const schema::Entity* VkSparseImageMemoryRequirements__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseImageMemoryRequirementsˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSparseImageOpaqueMemoryBindInfo:
// vulkan.VkSparseImageOpaqueMemoryBindInfo{Uint64,Uint32,$}
const schema::Entity* VkSparseImageOpaqueMemoryBindInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseImageOpaqueMemoryBindInfo",
        "",
        {
            schema::Field{"Image", new schema::Primitive{"VkImage", schema::Primitive::Uint64}},
            schema::Field{"BindCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PBinds", new schema::Struct{ VkSparseMemoryBind__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSparseImageOpaqueMemoryBindInfoˢ:
// vulkan.VkSparseImageOpaqueMemoryBindInfoˢ{$}
const schema::Entity* VkSparseImageOpaqueMemoryBindInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseImageOpaqueMemoryBindInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSparseImageOpaqueMemoryBindInfoᵖ:
// vulkan.VkSparseImageOpaqueMemoryBindInfoᵖ{Uint64,Uint32}
const schema::Entity* VkSparseImageOpaqueMemoryBindInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseImageOpaqueMemoryBindInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSparseMemoryBind:
// vulkan.VkSparseMemoryBind{Uint64,Uint64,Uint64,Uint64,Uint32}
void VkSparseMemoryBind::Encode(Encoder* e) const {
    e->Uint64(this->mResourceOffset);
    e->Uint64(this->mSize);
    e->Uint64(this->mMemory);
    e->Uint64(this->mMemoryOffset);
    e->Uint32(this->mFlags);
}
const schema::Entity* VkSparseMemoryBind::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseMemoryBind",
        "",
        {
            schema::Field{"ResourceOffset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Size", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Memory", new schema::Primitive{"VkDeviceMemory", schema::Primitive::Uint64}},
            schema::Field{"MemoryOffset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Flags", new schema::Primitive{"VkSparseMemoryBindFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSparseMemoryBindˢ:
// vulkan.VkSparseMemoryBindˢ{$}
const schema::Entity* VkSparseMemoryBind__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseMemoryBindˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSparseMemoryBindᵖ:
// vulkan.VkSparseMemoryBindᵖ{Uint64,Uint32}
const schema::Entity* VkSparseMemoryBind__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSparseMemoryBindᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSpecializationMapEntryᶜᵖ:
// vulkan.VkSpecializationMapEntryᶜᵖ{Uint64,Uint32}
const schema::Entity* VkSpecializationMapEntry__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSpecializationMapEntryᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSpecializationInfo:
// vulkan.VkSpecializationInfo{Uint32,$,Uint64,$}
void VkSpecializationInfo::Encode(Encoder* e) const {
    e->Uint32(this->mMapEntryCount);
    e->Struct(this->mPMapEntries);
    e->Uint64(this->mDataSize);
    e->Struct(this->mPData);
}
const schema::Entity* VkSpecializationInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSpecializationInfo",
        "",
        {
            schema::Field{"MapEntryCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PMapEntries", new schema::Struct{ VkSpecializationMapEntry__CP::StaticSchema()}},
            schema::Field{"DataSize", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"PData", new schema::Struct{ Void__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSpecializationInfoˢ:
// vulkan.VkSpecializationInfoˢ{$}
const schema::Entity* VkSpecializationInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSpecializationInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSpecializationInfoᵖ:
// vulkan.VkSpecializationInfoᵖ{Uint64,Uint32}
const schema::Entity* VkSpecializationInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSpecializationInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSpecializationMapEntry:
// vulkan.VkSpecializationMapEntry{Uint32,Uint32,Uint64}
const schema::Entity* VkSpecializationMapEntry::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSpecializationMapEntry",
        "",
        {
            schema::Field{"ConstantID", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Offset", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Size", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// VkSpecializationMapEntryˢ:
// vulkan.VkSpecializationMapEntryˢ{$}
const schema::Entity* VkSpecializationMapEntry__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSpecializationMapEntryˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSpecializationMapEntryᵖ:
// vulkan.VkSpecializationMapEntryᵖ{Uint64,Uint32}
const schema::Entity* VkSpecializationMapEntry__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSpecializationMapEntryᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkStructureTypeˢ:
// vulkan.VkStructureTypeˢ{$}
const schema::Entity* VkStructureType__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkStructureTypeˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkStructureTypeᵖ:
// vulkan.VkStructureTypeᵖ{Uint64,Uint32}
const schema::Entity* VkStructureType__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkStructureTypeᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSubmitInfo:
// vulkan.VkSubmitInfo{Uint32,$,Uint32,$,$,Uint32,$,Uint32,$}
void VkSubmitInfo::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mWaitSemaphoreCount);
    e->Struct(this->mPWaitSemaphores);
    e->Struct(this->mPWaitDstStageMask);
    e->Uint32(this->mCommandBufferCount);
    e->Struct(this->mPCommandBuffers);
    e->Uint32(this->mSignalSemaphoreCount);
    e->Struct(this->mPSignalSemaphores);
}
const schema::Entity* VkSubmitInfo::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSubmitInfo",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"WaitSemaphoreCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PWaitSemaphores", new schema::Struct{ VkSemaphore__CP::StaticSchema()}},
            schema::Field{"PWaitDstStageMask", new schema::Struct{ VkPipelineStageFlags__CP::StaticSchema()}},
            schema::Field{"CommandBufferCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PCommandBuffers", new schema::Struct{ VkCommandBuffer__CP::StaticSchema()}},
            schema::Field{"SignalSemaphoreCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PSignalSemaphores", new schema::Struct{ VkSemaphore__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSubmitInfoˢ:
// vulkan.VkSubmitInfoˢ{$}
const schema::Entity* VkSubmitInfo__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSubmitInfoˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSubmitInfoᵖ:
// vulkan.VkSubmitInfoᵖ{Uint64,Uint32}
const schema::Entity* VkSubmitInfo__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSubmitInfoᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSubpassDependency:
// vulkan.VkSubpassDependency{Uint32,Uint32,Uint32,Uint32,Uint32,Uint32,Uint32}
void VkSubpassDependency::Encode(Encoder* e) const {
    e->Uint32(this->mSrcSubpass);
    e->Uint32(this->mDstSubpass);
    e->Uint32(this->mSrcStageMask);
    e->Uint32(this->mDstStageMask);
    e->Uint32(this->mSrcAccessMask);
    e->Uint32(this->mDstAccessMask);
    e->Uint32(this->mDependencyFlags);
}
const schema::Entity* VkSubpassDependency::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSubpassDependency",
        "",
        {
            schema::Field{"SrcSubpass", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"DstSubpass", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"SrcStageMask", new schema::Primitive{"VkPipelineStageFlags", schema::Primitive::Uint32}},
            schema::Field{"DstStageMask", new schema::Primitive{"VkPipelineStageFlags", schema::Primitive::Uint32}},
            schema::Field{"SrcAccessMask", new schema::Primitive{"VkAccessFlags", schema::Primitive::Uint32}},
            schema::Field{"DstAccessMask", new schema::Primitive{"VkAccessFlags", schema::Primitive::Uint32}},
            schema::Field{"DependencyFlags", new schema::Primitive{"VkDependencyFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSubpassDependencyˢ:
// vulkan.VkSubpassDependencyˢ{$}
const schema::Entity* VkSubpassDependency__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSubpassDependencyˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSubpassDependencyᵖ:
// vulkan.VkSubpassDependencyᵖ{Uint64,Uint32}
const schema::Entity* VkSubpassDependency__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSubpassDependencyᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSubpassDescription:
// vulkan.VkSubpassDescription{Uint32,Uint32,Uint32,$,Uint32,$,$,$,Uint32,$}
void VkSubpassDescription::Encode(Encoder* e) const {
    e->Uint32(this->mFlags);
    e->Uint32(this->mPipelineBindPoint);
    e->Uint32(this->mInputAttachmentCount);
    e->Struct(this->mPInputAttachments);
    e->Uint32(this->mColorAttachmentCount);
    e->Struct(this->mPColorAttachments);
    e->Struct(this->mPResolveAttachments);
    e->Struct(this->mPDepthStencilAttachment);
    e->Uint32(this->mPreserveAttachmentCount);
    e->Struct(this->mPPreserveAttachments);
}
const schema::Entity* VkSubpassDescription::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSubpassDescription",
        "",
        {
            schema::Field{"Flags", new schema::Primitive{"VkSubpassDescriptionFlags", schema::Primitive::Uint32}},
            schema::Field{"PipelineBindPoint", new schema::Primitive{"VkPipelineBindPoint", schema::Primitive::Uint32}},
            schema::Field{"InputAttachmentCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PInputAttachments", new schema::Struct{ VkAttachmentReference__CP::StaticSchema()}},
            schema::Field{"ColorAttachmentCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PColorAttachments", new schema::Struct{ VkAttachmentReference__CP::StaticSchema()}},
            schema::Field{"PResolveAttachments", new schema::Struct{ VkAttachmentReference__CP::StaticSchema()}},
            schema::Field{"PDepthStencilAttachment", new schema::Struct{ VkAttachmentReference__CP::StaticSchema()}},
            schema::Field{"PreserveAttachmentCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PPreserveAttachments", new schema::Struct{ U32__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSubpassDescriptionˢ:
// vulkan.VkSubpassDescriptionˢ{$}
const schema::Entity* VkSubpassDescription__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSubpassDescriptionˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSubpassDescriptionᵖ:
// vulkan.VkSubpassDescriptionᵖ{Uint64,Uint32}
const schema::Entity* VkSubpassDescription__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSubpassDescriptionᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSubresourceLayout:
// vulkan.VkSubresourceLayout{Uint64,Uint64,Uint64,Uint64,Uint64}
void VkSubresourceLayout::Encode(Encoder* e) const {
    e->Uint64(this->mOffset);
    e->Uint64(this->mSize);
    e->Uint64(this->mRowPitch);
    e->Uint64(this->mArrayPitch);
    e->Uint64(this->mDepthPitch);
}
const schema::Entity* VkSubresourceLayout::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSubresourceLayout",
        "",
        {
            schema::Field{"Offset", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"Size", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"RowPitch", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"ArrayPitch", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
            schema::Field{"DepthPitch", new schema::Primitive{"VkDeviceSize", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// VkSubresourceLayoutˢ:
// vulkan.VkSubresourceLayoutˢ{$}
const schema::Entity* VkSubresourceLayout__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSubresourceLayoutˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSurfaceCapabilitiesKHR:
// vulkan.VkSurfaceCapabilitiesKHR{Uint32,Uint32,$,$,$,Uint32,Uint32,Uint32,Uint32,Uint32}
void VkSurfaceCapabilitiesKHR::Encode(Encoder* e) const {
    e->Uint32(this->mMinImageCount);
    e->Uint32(this->mMaxImageCount);
    e->Struct(this->mCurrentExtent);
    e->Struct(this->mMinImageExtent);
    e->Struct(this->mMaxImageExtent);
    e->Uint32(this->mMaxImageArrayLayers);
    e->Uint32(this->mSupportedTransforms);
    e->Uint32(this->mCurrentTransform);
    e->Uint32(this->mSupportedCompositeAlpha);
    e->Uint32(this->mSupportedUsageFlags);
}
const schema::Entity* VkSurfaceCapabilitiesKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSurfaceCapabilitiesKHR",
        "",
        {
            schema::Field{"MinImageCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"MaxImageCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"CurrentExtent", new schema::Struct{ VkExtent2D::StaticSchema()}},
            schema::Field{"MinImageExtent", new schema::Struct{ VkExtent2D::StaticSchema()}},
            schema::Field{"MaxImageExtent", new schema::Struct{ VkExtent2D::StaticSchema()}},
            schema::Field{"MaxImageArrayLayers", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"SupportedTransforms", new schema::Primitive{"VkSurfaceTransformFlagsKHR", schema::Primitive::Uint32}},
            schema::Field{"CurrentTransform", new schema::Primitive{"VkSurfaceTransformFlagBitsKHR", schema::Primitive::Uint32}},
            schema::Field{"SupportedCompositeAlpha", new schema::Primitive{"VkCompositeAlphaFlagsKHR", schema::Primitive::Uint32}},
            schema::Field{"SupportedUsageFlags", new schema::Primitive{"VkImageUsageFlags", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSurfaceCapabilitiesKHRˢ:
// vulkan.VkSurfaceCapabilitiesKHRˢ{$}
const schema::Entity* VkSurfaceCapabilitiesKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSurfaceCapabilitiesKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSurfaceFormatKHR:
// vulkan.VkSurfaceFormatKHR{Uint32,Uint32}
const schema::Entity* VkSurfaceFormatKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSurfaceFormatKHR",
        "",
        {
            schema::Field{"Format", new schema::Primitive{"VkFormat", schema::Primitive::Uint32}},
            schema::Field{"ColorSpace", new schema::Primitive{"VkColorSpaceKHR", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSurfaceFormatKHRˢ:
// vulkan.VkSurfaceFormatKHRˢ{$}
const schema::Entity* VkSurfaceFormatKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSurfaceFormatKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSurfaceKHRˢ:
// vulkan.VkSurfaceKHRˢ{$}
const schema::Entity* VkSurfaceKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSurfaceKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSwapchainCreateInfoKHR:
// vulkan.VkSwapchainCreateInfoKHR{Uint32,$,Uint32,Uint64,Uint32,Uint32,Uint32,$,Uint32,Uint32,Uint32,Uint32,$,Uint32,Uint32,Uint32,Uint32,Uint64}
void VkSwapchainCreateInfoKHR::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint32(this->mFlags);
    e->Uint64(this->mSurface);
    e->Uint32(this->mMinImageCount);
    e->Uint32(this->mImageFormat);
    e->Uint32(this->mImageColorSpace);
    e->Struct(this->mImageExtent);
    e->Uint32(this->mImageArrayLayers);
    e->Uint32(this->mImageUsage);
    e->Uint32(this->mImageSharingMode);
    e->Uint32(this->mQueueFamilyIndexCount);
    e->Struct(this->mPQueueFamilyIndices);
    e->Uint32(this->mPreTransform);
    e->Uint32(this->mCompositeAlpha);
    e->Uint32(this->mPresentMode);
    e->Uint32(this->mClipped);
    e->Uint64(this->mOldSwapchain);
}
const schema::Entity* VkSwapchainCreateInfoKHR::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSwapchainCreateInfoKHR",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"Flags", new schema::Primitive{"VkSwapchainCreateFlagsKHR", schema::Primitive::Uint32}},
            schema::Field{"Surface", new schema::Primitive{"VkSurfaceKHR", schema::Primitive::Uint64}},
            schema::Field{"MinImageCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"ImageFormat", new schema::Primitive{"VkFormat", schema::Primitive::Uint32}},
            schema::Field{"ImageColorSpace", new schema::Primitive{"VkColorSpaceKHR", schema::Primitive::Uint32}},
            schema::Field{"ImageExtent", new schema::Struct{ VkExtent2D::StaticSchema()}},
            schema::Field{"ImageArrayLayers", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"ImageUsage", new schema::Primitive{"VkImageUsageFlags", schema::Primitive::Uint32}},
            schema::Field{"ImageSharingMode", new schema::Primitive{"VkSharingMode", schema::Primitive::Uint32}},
            schema::Field{"QueueFamilyIndexCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PQueueFamilyIndices", new schema::Struct{ U32__CP::StaticSchema()}},
            schema::Field{"PreTransform", new schema::Primitive{"VkSurfaceTransformFlagBitsKHR", schema::Primitive::Uint32}},
            schema::Field{"CompositeAlpha", new schema::Primitive{"VkCompositeAlphaFlagBitsKHR", schema::Primitive::Uint32}},
            schema::Field{"PresentMode", new schema::Primitive{"VkPresentModeKHR", schema::Primitive::Uint32}},
            schema::Field{"Clipped", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"OldSwapchain", new schema::Primitive{"VkSwapchainKHR", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// VkSwapchainCreateInfoKHRˢ:
// vulkan.VkSwapchainCreateInfoKHRˢ{$}
const schema::Entity* VkSwapchainCreateInfoKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSwapchainCreateInfoKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkSwapchainCreateInfoKHRᵖ:
// vulkan.VkSwapchainCreateInfoKHRᵖ{Uint64,Uint32}
const schema::Entity* VkSwapchainCreateInfoKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSwapchainCreateInfoKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkSwapchainKHRˢ:
// vulkan.VkSwapchainKHRˢ{$}
const schema::Entity* VkSwapchainKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkSwapchainKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkUnmapMemory:
// vulkan.VkUnmapMemory{[]?,Uint64,Uint64}
const schema::Entity* VkUnmapMemory::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkUnmapMemory",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"Memory", new schema::Primitive{"VkDeviceMemory", schema::Primitive::Uint64}},
        },
    };
    return &entity;
}

// VkWriteDescriptorSetᶜᵖ:
// vulkan.VkWriteDescriptorSetᶜᵖ{Uint64,Uint32}
const schema::Entity* VkWriteDescriptorSet__CP::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkWriteDescriptorSetᶜᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkUpdateDescriptorSets:
// vulkan.VkUpdateDescriptorSets{[]?,Uint64,Uint32,$,Uint32,$}
void VkUpdateDescriptorSets::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint32(this->mDescriptorWriteCount);
    e->Struct(this->mPDescriptorWrites);
    e->Uint32(this->mDescriptorCopyCount);
    e->Struct(this->mPDescriptorCopies);
}
const schema::Entity* VkUpdateDescriptorSets::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkUpdateDescriptorSets",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"DescriptorWriteCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PDescriptorWrites", new schema::Struct{ VkWriteDescriptorSet__CP::StaticSchema()}},
            schema::Field{"DescriptorCopyCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PDescriptorCopies", new schema::Struct{ VkCopyDescriptorSet__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkVertexInputAttributeDescription:
// vulkan.VkVertexInputAttributeDescription{Uint32,Uint32,Uint32,Uint32}
void VkVertexInputAttributeDescription::Encode(Encoder* e) const {
    e->Uint32(this->mLocation);
    e->Uint32(this->mBinding);
    e->Uint32(this->mFormat);
    e->Uint32(this->mOffset);
}
const schema::Entity* VkVertexInputAttributeDescription::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkVertexInputAttributeDescription",
        "",
        {
            schema::Field{"Location", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Binding", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Format", new schema::Primitive{"VkFormat", schema::Primitive::Uint32}},
            schema::Field{"Offset", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkVertexInputAttributeDescriptionˢ:
// vulkan.VkVertexInputAttributeDescriptionˢ{$}
const schema::Entity* VkVertexInputAttributeDescription__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkVertexInputAttributeDescriptionˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkVertexInputAttributeDescriptionᵖ:
// vulkan.VkVertexInputAttributeDescriptionᵖ{Uint64,Uint32}
const schema::Entity* VkVertexInputAttributeDescription__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkVertexInputAttributeDescriptionᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkVertexInputBindingDescription:
// vulkan.VkVertexInputBindingDescription{Uint32,Uint32,Uint32}
const schema::Entity* VkVertexInputBindingDescription::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkVertexInputBindingDescription",
        "",
        {
            schema::Field{"Binding", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"Stride", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"InputRate", new schema::Primitive{"VkVertexInputRate", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkVertexInputBindingDescriptionˢ:
// vulkan.VkVertexInputBindingDescriptionˢ{$}
const schema::Entity* VkVertexInputBindingDescription__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkVertexInputBindingDescriptionˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkVertexInputBindingDescriptionᵖ:
// vulkan.VkVertexInputBindingDescriptionᵖ{Uint64,Uint32}
const schema::Entity* VkVertexInputBindingDescription__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkVertexInputBindingDescriptionᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkViewport:
// vulkan.VkViewport{Float32,Float32,Float32,Float32,Float32,Float32}
void VkViewport::Encode(Encoder* e) const {
    e->Float32(this->mX);
    e->Float32(this->mY);
    e->Float32(this->mWidth);
    e->Float32(this->mHeight);
    e->Float32(this->mMinDepth);
    e->Float32(this->mMaxDepth);
}
const schema::Entity* VkViewport::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkViewport",
        "",
        {
            schema::Field{"X", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"Y", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"Width", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"Height", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"MinDepth", new schema::Primitive{"float32", schema::Primitive::Float32}},
            schema::Field{"MaxDepth", new schema::Primitive{"float32", schema::Primitive::Float32}},
        },
    };
    return &entity;
}

// VkViewportˢ:
// vulkan.VkViewportˢ{$}
const schema::Entity* VkViewport__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkViewportˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkViewportᵖ:
// vulkan.VkViewportᵖ{Uint64,Uint32}
const schema::Entity* VkViewport__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkViewportᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkWaitForFences:
// vulkan.VkWaitForFences{[]?,Uint64,Uint32,$,Uint32,Uint64,Uint32}
void VkWaitForFences::Encode(Encoder* e) const {
    e->Uint32(this->mextras.count());
    for (auto v : this->mextras) {
        e->Object(v);
    }
    e->Uint64(this->mDevice);
    e->Uint32(this->mFenceCount);
    e->Struct(this->mPFences);
    e->Uint32(this->mWaitAll);
    e->Uint64(this->mTimeout);
    e->Uint32(this->mResult);
}
const schema::Entity* VkWaitForFences::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkWaitForFences",
        "",
        {
            schema::Field{"extras", new schema::Slice{"atom.Extras", new schema::Interface{"atom.Extra"}}},
            schema::Field{"Device", new schema::Primitive{"VkDevice", schema::Primitive::Uint64}},
            schema::Field{"FenceCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"PFences", new schema::Struct{ VkFence__CP::StaticSchema()}},
            schema::Field{"WaitAll", new schema::Primitive{"VkBool32", schema::Primitive::Uint32}},
            schema::Field{"Timeout", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Result", new schema::Primitive{"VkResult", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// Wl_surfaceᵖ:
// vulkan.Wl_surfaceᵖ{Uint64,Uint32}
const schema::Entity* Wl_surface__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Wl_surfaceᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkWaylandSurfaceCreateInfoKHRˢ:
// vulkan.VkWaylandSurfaceCreateInfoKHRˢ{$}
const schema::Entity* VkWaylandSurfaceCreateInfoKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkWaylandSurfaceCreateInfoKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkWaylandSurfaceCreateInfoKHRᵖ:
// vulkan.VkWaylandSurfaceCreateInfoKHRᵖ{Uint64,Uint32}
const schema::Entity* VkWaylandSurfaceCreateInfoKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkWaylandSurfaceCreateInfoKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkWriteDescriptorSet:
// vulkan.VkWriteDescriptorSet{Uint32,$,Uint64,Uint32,Uint32,Uint32,Uint32,$,$,$}
void VkWriteDescriptorSet::Encode(Encoder* e) const {
    e->Uint32(this->mSType);
    e->Struct(this->mPNext);
    e->Uint64(this->mDstSet);
    e->Uint32(this->mDstBinding);
    e->Uint32(this->mDstArrayElement);
    e->Uint32(this->mDescriptorCount);
    e->Uint32(this->mDescriptorType);
    e->Struct(this->mPImageInfo);
    e->Struct(this->mPBufferInfo);
    e->Struct(this->mPTexelBufferView);
}
const schema::Entity* VkWriteDescriptorSet::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkWriteDescriptorSet",
        "",
        {
            schema::Field{"SType", new schema::Primitive{"VkStructureType", schema::Primitive::Uint32}},
            schema::Field{"PNext", new schema::Struct{ Void__CP::StaticSchema()}},
            schema::Field{"DstSet", new schema::Primitive{"VkDescriptorSet", schema::Primitive::Uint64}},
            schema::Field{"DstBinding", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"DstArrayElement", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"DescriptorCount", new schema::Primitive{"uint32", schema::Primitive::Uint32}},
            schema::Field{"DescriptorType", new schema::Primitive{"VkDescriptorType", schema::Primitive::Uint32}},
            schema::Field{"PImageInfo", new schema::Struct{ VkDescriptorImageInfo__CP::StaticSchema()}},
            schema::Field{"PBufferInfo", new schema::Struct{ VkDescriptorBufferInfo__CP::StaticSchema()}},
            schema::Field{"PTexelBufferView", new schema::Struct{ VkBufferView__CP::StaticSchema()}},
        },
    };
    return &entity;
}

// VkWriteDescriptorSetˢ:
// vulkan.VkWriteDescriptorSetˢ{$}
const schema::Entity* VkWriteDescriptorSet__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkWriteDescriptorSetˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkWriteDescriptorSetᵖ:
// vulkan.VkWriteDescriptorSetᵖ{Uint64,Uint32}
const schema::Entity* VkWriteDescriptorSet__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkWriteDescriptorSetᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkXcbSurfaceCreateInfoKHRˢ:
// vulkan.VkXcbSurfaceCreateInfoKHRˢ{$}
const schema::Entity* VkXcbSurfaceCreateInfoKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkXcbSurfaceCreateInfoKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkXcbSurfaceCreateInfoKHRᵖ:
// vulkan.VkXcbSurfaceCreateInfoKHRᵖ{Uint64,Uint32}
const schema::Entity* VkXcbSurfaceCreateInfoKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkXcbSurfaceCreateInfoKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// VkXlibSurfaceCreateInfoKHRˢ:
// vulkan.VkXlibSurfaceCreateInfoKHRˢ{$}
const schema::Entity* VkXlibSurfaceCreateInfoKHR__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkXlibSurfaceCreateInfoKHRˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// VkXlibSurfaceCreateInfoKHRᵖ:
// vulkan.VkXlibSurfaceCreateInfoKHRᵖ{Uint64,Uint32}
const schema::Entity* VkXlibSurfaceCreateInfoKHR__P::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "VkXlibSurfaceCreateInfoKHRᵖ",
        "",
        {
            schema::Field{"Address", new schema::Primitive{"uint64", schema::Primitive::Uint64}},
            schema::Field{"Pool", new schema::Primitive{"memory.PoolID", schema::Primitive::Uint32}},
        },
    };
    return &entity;
}

// Voidˢ:
// vulkan.Voidˢ{$}
const schema::Entity* Void__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Voidˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// Voidᵖˢ:
// vulkan.Voidᵖˢ{$}
const schema::Entity* Void__P__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Voidᵖˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// Wl_displayˢ:
// vulkan.Wl_displayˢ{$}
const schema::Entity* Wl_display__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Wl_displayˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// Wl_surfaceˢ:
// vulkan.Wl_surfaceˢ{$}
const schema::Entity* Wl_surface__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Wl_surfaceˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}

// Xcb_connection_tˢ:
// vulkan.Xcb_connection_tˢ{$}
const schema::Entity* Xcb_connection_t__S::StaticSchema() {
    static schema::Entity entity {
        "vulkan",
        "",
        "Xcb_connection_tˢ",
        "",
        {
            schema::Field{"", new schema::Struct{ memory::SliceInfo::StaticSchema()}},
        },
    };
    return &entity;
}



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