diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9efd309..e675d72 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -6,7 +6,7 @@
 cmake_minimum_required(VERSION 3.22.1)
 
 # The VERSION field is generated with the "--generated-version" flag in the generate_source.py script
-project(VUL VERSION 1.4.343 LANGUAGES CXX)
+project(VUL VERSION 1.4.344 LANGUAGES CXX)
 
 set_property(GLOBAL PROPERTY USE_FOLDERS ON) # Remove when min is 3.26, see CMP0143
 
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 9c92d6a..70d1369 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -26,65 +26,6 @@ namespace vku {
 // before vkCreateInstance() and not modified afterwards.
 std::vector<std::pair<uint32_t, uint32_t>>& GetCustomStypeInfo();
 
-struct safe_VkBufferMemoryBarrier {
-    VkStructureType sType;
-    const void* pNext{};
-    VkAccessFlags srcAccessMask;
-    VkAccessFlags dstAccessMask;
-    uint32_t srcQueueFamilyIndex;
-    uint32_t dstQueueFamilyIndex;
-    VkBuffer buffer;
-    VkDeviceSize offset;
-    VkDeviceSize size;
-
-    safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& copy_src);
-    safe_VkBufferMemoryBarrier& operator=(const safe_VkBufferMemoryBarrier& copy_src);
-    safe_VkBufferMemoryBarrier();
-    ~safe_VkBufferMemoryBarrier();
-    void initialize(const VkBufferMemoryBarrier* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkBufferMemoryBarrier* copy_src, PNextCopyState* copy_state = {});
-    VkBufferMemoryBarrier* ptr() { return reinterpret_cast<VkBufferMemoryBarrier*>(this); }
-    VkBufferMemoryBarrier const* ptr() const { return reinterpret_cast<VkBufferMemoryBarrier const*>(this); }
-};
-struct safe_VkImageMemoryBarrier {
-    VkStructureType sType;
-    const void* pNext{};
-    VkAccessFlags srcAccessMask;
-    VkAccessFlags dstAccessMask;
-    VkImageLayout oldLayout;
-    VkImageLayout newLayout;
-    uint32_t srcQueueFamilyIndex;
-    uint32_t dstQueueFamilyIndex;
-    VkImage image;
-    VkImageSubresourceRange subresourceRange;
-
-    safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& copy_src);
-    safe_VkImageMemoryBarrier& operator=(const safe_VkImageMemoryBarrier& copy_src);
-    safe_VkImageMemoryBarrier();
-    ~safe_VkImageMemoryBarrier();
-    void initialize(const VkImageMemoryBarrier* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkImageMemoryBarrier* copy_src, PNextCopyState* copy_state = {});
-    VkImageMemoryBarrier* ptr() { return reinterpret_cast<VkImageMemoryBarrier*>(this); }
-    VkImageMemoryBarrier const* ptr() const { return reinterpret_cast<VkImageMemoryBarrier const*>(this); }
-};
-struct safe_VkMemoryBarrier {
-    VkStructureType sType;
-    const void* pNext{};
-    VkAccessFlags srcAccessMask;
-    VkAccessFlags dstAccessMask;
-
-    safe_VkMemoryBarrier(const VkMemoryBarrier* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkMemoryBarrier(const safe_VkMemoryBarrier& copy_src);
-    safe_VkMemoryBarrier& operator=(const safe_VkMemoryBarrier& copy_src);
-    safe_VkMemoryBarrier();
-    ~safe_VkMemoryBarrier();
-    void initialize(const VkMemoryBarrier* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkMemoryBarrier* copy_src, PNextCopyState* copy_state = {});
-    VkMemoryBarrier* ptr() { return reinterpret_cast<VkMemoryBarrier*>(this); }
-    VkMemoryBarrier const* ptr() const { return reinterpret_cast<VkMemoryBarrier const*>(this); }
-};
 struct safe_VkAllocationCallbacks {
     void* pUserData{};
     PFN_vkAllocationFunction pfnAllocation;
@@ -236,6 +177,21 @@ struct safe_VkMemoryAllocateInfo {
     VkMemoryAllocateInfo* ptr() { return reinterpret_cast<VkMemoryAllocateInfo*>(this); }
     VkMemoryAllocateInfo const* ptr() const { return reinterpret_cast<VkMemoryAllocateInfo const*>(this); }
 };
+struct safe_VkSparseImageMemoryBindInfo {
+    VkImage image;
+    uint32_t bindCount;
+    VkSparseImageMemoryBind* pBinds{};
+
+    safe_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* in_struct, PNextCopyState* copy_state = {});
+    safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& copy_src);
+    safe_VkSparseImageMemoryBindInfo& operator=(const safe_VkSparseImageMemoryBindInfo& copy_src);
+    safe_VkSparseImageMemoryBindInfo();
+    ~safe_VkSparseImageMemoryBindInfo();
+    void initialize(const VkSparseImageMemoryBindInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSparseImageMemoryBindInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSparseImageMemoryBindInfo* ptr() { return reinterpret_cast<VkSparseImageMemoryBindInfo*>(this); }
+    VkSparseImageMemoryBindInfo const* ptr() const { return reinterpret_cast<VkSparseImageMemoryBindInfo const*>(this); }
+};
 struct safe_VkSparseBufferMemoryBindInfo {
     VkBuffer buffer;
     uint32_t bindCount;
@@ -268,21 +224,6 @@ struct safe_VkSparseImageOpaqueMemoryBindInfo {
         return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo const*>(this);
     }
 };
-struct safe_VkSparseImageMemoryBindInfo {
-    VkImage image;
-    uint32_t bindCount;
-    VkSparseImageMemoryBind* pBinds{};
-
-    safe_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* in_struct, PNextCopyState* copy_state = {});
-    safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& copy_src);
-    safe_VkSparseImageMemoryBindInfo& operator=(const safe_VkSparseImageMemoryBindInfo& copy_src);
-    safe_VkSparseImageMemoryBindInfo();
-    ~safe_VkSparseImageMemoryBindInfo();
-    void initialize(const VkSparseImageMemoryBindInfo* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkSparseImageMemoryBindInfo* copy_src, PNextCopyState* copy_state = {});
-    VkSparseImageMemoryBindInfo* ptr() { return reinterpret_cast<VkSparseImageMemoryBindInfo*>(this); }
-    VkSparseImageMemoryBindInfo const* ptr() const { return reinterpret_cast<VkSparseImageMemoryBindInfo const*>(this); }
-};
 struct safe_VkBindSparseInfo {
     VkStructureType sType;
     const void* pNext{};
@@ -494,6 +435,65 @@ struct safe_VkCommandBufferBeginInfo {
     VkCommandBufferBeginInfo* ptr() { return reinterpret_cast<VkCommandBufferBeginInfo*>(this); }
     VkCommandBufferBeginInfo const* ptr() const { return reinterpret_cast<VkCommandBufferBeginInfo const*>(this); }
 };
+struct safe_VkBufferMemoryBarrier {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccessFlags srcAccessMask;
+    VkAccessFlags dstAccessMask;
+    uint32_t srcQueueFamilyIndex;
+    uint32_t dstQueueFamilyIndex;
+    VkBuffer buffer;
+    VkDeviceSize offset;
+    VkDeviceSize size;
+
+    safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& copy_src);
+    safe_VkBufferMemoryBarrier& operator=(const safe_VkBufferMemoryBarrier& copy_src);
+    safe_VkBufferMemoryBarrier();
+    ~safe_VkBufferMemoryBarrier();
+    void initialize(const VkBufferMemoryBarrier* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferMemoryBarrier* copy_src, PNextCopyState* copy_state = {});
+    VkBufferMemoryBarrier* ptr() { return reinterpret_cast<VkBufferMemoryBarrier*>(this); }
+    VkBufferMemoryBarrier const* ptr() const { return reinterpret_cast<VkBufferMemoryBarrier const*>(this); }
+};
+struct safe_VkImageMemoryBarrier {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccessFlags srcAccessMask;
+    VkAccessFlags dstAccessMask;
+    VkImageLayout oldLayout;
+    VkImageLayout newLayout;
+    uint32_t srcQueueFamilyIndex;
+    uint32_t dstQueueFamilyIndex;
+    VkImage image;
+    VkImageSubresourceRange subresourceRange;
+
+    safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& copy_src);
+    safe_VkImageMemoryBarrier& operator=(const safe_VkImageMemoryBarrier& copy_src);
+    safe_VkImageMemoryBarrier();
+    ~safe_VkImageMemoryBarrier();
+    void initialize(const VkImageMemoryBarrier* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageMemoryBarrier* copy_src, PNextCopyState* copy_state = {});
+    VkImageMemoryBarrier* ptr() { return reinterpret_cast<VkImageMemoryBarrier*>(this); }
+    VkImageMemoryBarrier const* ptr() const { return reinterpret_cast<VkImageMemoryBarrier const*>(this); }
+};
+struct safe_VkMemoryBarrier {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccessFlags srcAccessMask;
+    VkAccessFlags dstAccessMask;
+
+    safe_VkMemoryBarrier(const VkMemoryBarrier* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryBarrier(const safe_VkMemoryBarrier& copy_src);
+    safe_VkMemoryBarrier& operator=(const safe_VkMemoryBarrier& copy_src);
+    safe_VkMemoryBarrier();
+    ~safe_VkMemoryBarrier();
+    void initialize(const VkMemoryBarrier* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryBarrier* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryBarrier* ptr() { return reinterpret_cast<VkMemoryBarrier*>(this); }
+    VkMemoryBarrier const* ptr() const { return reinterpret_cast<VkMemoryBarrier const*>(this); }
+};
 struct safe_VkEventCreateInfo {
     VkStructureType sType;
     const void* pNext{};
@@ -794,28 +794,74 @@ struct safe_VkWriteDescriptorSet {
     VkWriteDescriptorSet* ptr() { return reinterpret_cast<VkWriteDescriptorSet*>(this); }
     VkWriteDescriptorSet const* ptr() const { return reinterpret_cast<VkWriteDescriptorSet const*>(this); }
 };
-struct safe_VkPipelineVertexInputStateCreateInfo {
+struct safe_VkPipelineColorBlendStateCreateInfo {
     VkStructureType sType;
     const void* pNext{};
-    VkPipelineVertexInputStateCreateFlags flags;
-    uint32_t vertexBindingDescriptionCount;
-    const VkVertexInputBindingDescription* pVertexBindingDescriptions{};
-    uint32_t vertexAttributeDescriptionCount;
-    const VkVertexInputAttributeDescription* pVertexAttributeDescriptions{};
+    VkPipelineColorBlendStateCreateFlags flags;
+    VkBool32 logicOpEnable;
+    VkLogicOp logicOp;
+    uint32_t attachmentCount;
+    const VkPipelineColorBlendAttachmentState* pAttachments{};
+    float blendConstants[4];
 
-    safe_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo* in_struct,
-                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPipelineVertexInputStateCreateInfo(const safe_VkPipelineVertexInputStateCreateInfo& copy_src);
-    safe_VkPipelineVertexInputStateCreateInfo& operator=(const safe_VkPipelineVertexInputStateCreateInfo& copy_src);
-    safe_VkPipelineVertexInputStateCreateInfo();
-    ~safe_VkPipelineVertexInputStateCreateInfo();
-    void initialize(const VkPipelineVertexInputStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPipelineVertexInputStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
-    VkPipelineVertexInputStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>(this); }
-    VkPipelineVertexInputStateCreateInfo const* ptr() const {
-        return reinterpret_cast<VkPipelineVertexInputStateCreateInfo const*>(this);
+    safe_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkPipelineColorBlendStateCreateInfo(const safe_VkPipelineColorBlendStateCreateInfo& copy_src);
+    safe_VkPipelineColorBlendStateCreateInfo& operator=(const safe_VkPipelineColorBlendStateCreateInfo& copy_src);
+    safe_VkPipelineColorBlendStateCreateInfo();
+    ~safe_VkPipelineColorBlendStateCreateInfo();
+    void initialize(const VkPipelineColorBlendStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineColorBlendStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineColorBlendStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(this); }
+    VkPipelineColorBlendStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineColorBlendStateCreateInfo const*>(this);
     }
 };
+struct safe_VkPipelineDepthStencilStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineDepthStencilStateCreateFlags flags;
+    VkBool32 depthTestEnable;
+    VkBool32 depthWriteEnable;
+    VkCompareOp depthCompareOp;
+    VkBool32 depthBoundsTestEnable;
+    VkBool32 stencilTestEnable;
+    VkStencilOpState front;
+    VkStencilOpState back;
+    float minDepthBounds;
+    float maxDepthBounds;
+
+    safe_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineDepthStencilStateCreateInfo(const safe_VkPipelineDepthStencilStateCreateInfo& copy_src);
+    safe_VkPipelineDepthStencilStateCreateInfo& operator=(const safe_VkPipelineDepthStencilStateCreateInfo& copy_src);
+    safe_VkPipelineDepthStencilStateCreateInfo();
+    ~safe_VkPipelineDepthStencilStateCreateInfo();
+    void initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineDepthStencilStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineDepthStencilStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>(this); }
+    VkPipelineDepthStencilStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo const*>(this);
+    }
+};
+struct safe_VkPipelineDynamicStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineDynamicStateCreateFlags flags;
+    uint32_t dynamicStateCount;
+    const VkDynamicState* pDynamicStates{};
+
+    safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkPipelineDynamicStateCreateInfo(const safe_VkPipelineDynamicStateCreateInfo& copy_src);
+    safe_VkPipelineDynamicStateCreateInfo& operator=(const safe_VkPipelineDynamicStateCreateInfo& copy_src);
+    safe_VkPipelineDynamicStateCreateInfo();
+    ~safe_VkPipelineDynamicStateCreateInfo();
+    void initialize(const VkPipelineDynamicStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineDynamicStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineDynamicStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineDynamicStateCreateInfo*>(this); }
+    VkPipelineDynamicStateCreateInfo const* ptr() const { return reinterpret_cast<VkPipelineDynamicStateCreateInfo const*>(this); }
+};
 struct safe_VkPipelineInputAssemblyStateCreateInfo {
     VkStructureType sType;
     const void* pNext{};
@@ -836,46 +882,28 @@ struct safe_VkPipelineInputAssemblyStateCreateInfo {
         return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo const*>(this);
     }
 };
-struct safe_VkPipelineTessellationStateCreateInfo {
-    VkStructureType sType;
-    const void* pNext{};
-    VkPipelineTessellationStateCreateFlags flags;
-    uint32_t patchControlPoints;
-
-    safe_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo* in_struct,
-                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPipelineTessellationStateCreateInfo(const safe_VkPipelineTessellationStateCreateInfo& copy_src);
-    safe_VkPipelineTessellationStateCreateInfo& operator=(const safe_VkPipelineTessellationStateCreateInfo& copy_src);
-    safe_VkPipelineTessellationStateCreateInfo();
-    ~safe_VkPipelineTessellationStateCreateInfo();
-    void initialize(const VkPipelineTessellationStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPipelineTessellationStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
-    VkPipelineTessellationStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineTessellationStateCreateInfo*>(this); }
-    VkPipelineTessellationStateCreateInfo const* ptr() const {
-        return reinterpret_cast<VkPipelineTessellationStateCreateInfo const*>(this);
-    }
-};
-struct safe_VkPipelineViewportStateCreateInfo {
+struct safe_VkPipelineMultisampleStateCreateInfo {
     VkStructureType sType;
     const void* pNext{};
-    VkPipelineViewportStateCreateFlags flags;
-    uint32_t viewportCount;
-    const VkViewport* pViewports{};
-    uint32_t scissorCount;
-    const VkRect2D* pScissors{};
+    VkPipelineMultisampleStateCreateFlags flags;
+    VkSampleCountFlagBits rasterizationSamples;
+    VkBool32 sampleShadingEnable;
+    float minSampleShading;
+    const VkSampleMask* pSampleMask{};
+    VkBool32 alphaToCoverageEnable;
+    VkBool32 alphaToOneEnable;
 
-    safe_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports,
-                                           const bool is_dynamic_scissors, PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPipelineViewportStateCreateInfo(const safe_VkPipelineViewportStateCreateInfo& copy_src);
-    safe_VkPipelineViewportStateCreateInfo& operator=(const safe_VkPipelineViewportStateCreateInfo& copy_src);
-    safe_VkPipelineViewportStateCreateInfo();
-    ~safe_VkPipelineViewportStateCreateInfo();
-    void initialize(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports,
-                    const bool is_dynamic_scissors, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPipelineViewportStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
-    VkPipelineViewportStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineViewportStateCreateInfo*>(this); }
-    VkPipelineViewportStateCreateInfo const* ptr() const {
-        return reinterpret_cast<VkPipelineViewportStateCreateInfo const*>(this);
+    safe_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineMultisampleStateCreateInfo(const safe_VkPipelineMultisampleStateCreateInfo& copy_src);
+    safe_VkPipelineMultisampleStateCreateInfo& operator=(const safe_VkPipelineMultisampleStateCreateInfo& copy_src);
+    safe_VkPipelineMultisampleStateCreateInfo();
+    ~safe_VkPipelineMultisampleStateCreateInfo();
+    void initialize(const VkPipelineMultisampleStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineMultisampleStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineMultisampleStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>(this); }
+    VkPipelineMultisampleStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineMultisampleStateCreateInfo const*>(this);
     }
 };
 struct safe_VkPipelineRasterizationStateCreateInfo {
@@ -906,97 +934,69 @@ struct safe_VkPipelineRasterizationStateCreateInfo {
         return reinterpret_cast<VkPipelineRasterizationStateCreateInfo const*>(this);
     }
 };
-struct safe_VkPipelineMultisampleStateCreateInfo {
-    VkStructureType sType;
-    const void* pNext{};
-    VkPipelineMultisampleStateCreateFlags flags;
-    VkSampleCountFlagBits rasterizationSamples;
-    VkBool32 sampleShadingEnable;
-    float minSampleShading;
-    const VkSampleMask* pSampleMask{};
-    VkBool32 alphaToCoverageEnable;
-    VkBool32 alphaToOneEnable;
-
-    safe_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo* in_struct,
-                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPipelineMultisampleStateCreateInfo(const safe_VkPipelineMultisampleStateCreateInfo& copy_src);
-    safe_VkPipelineMultisampleStateCreateInfo& operator=(const safe_VkPipelineMultisampleStateCreateInfo& copy_src);
-    safe_VkPipelineMultisampleStateCreateInfo();
-    ~safe_VkPipelineMultisampleStateCreateInfo();
-    void initialize(const VkPipelineMultisampleStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPipelineMultisampleStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
-    VkPipelineMultisampleStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>(this); }
-    VkPipelineMultisampleStateCreateInfo const* ptr() const {
-        return reinterpret_cast<VkPipelineMultisampleStateCreateInfo const*>(this);
-    }
-};
-struct safe_VkPipelineDepthStencilStateCreateInfo {
+struct safe_VkPipelineTessellationStateCreateInfo {
     VkStructureType sType;
     const void* pNext{};
-    VkPipelineDepthStencilStateCreateFlags flags;
-    VkBool32 depthTestEnable;
-    VkBool32 depthWriteEnable;
-    VkCompareOp depthCompareOp;
-    VkBool32 depthBoundsTestEnable;
-    VkBool32 stencilTestEnable;
-    VkStencilOpState front;
-    VkStencilOpState back;
-    float minDepthBounds;
-    float maxDepthBounds;
+    VkPipelineTessellationStateCreateFlags flags;
+    uint32_t patchControlPoints;
 
-    safe_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo* in_struct,
+    safe_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo* in_struct,
                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPipelineDepthStencilStateCreateInfo(const safe_VkPipelineDepthStencilStateCreateInfo& copy_src);
-    safe_VkPipelineDepthStencilStateCreateInfo& operator=(const safe_VkPipelineDepthStencilStateCreateInfo& copy_src);
-    safe_VkPipelineDepthStencilStateCreateInfo();
-    ~safe_VkPipelineDepthStencilStateCreateInfo();
-    void initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPipelineDepthStencilStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
-    VkPipelineDepthStencilStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>(this); }
-    VkPipelineDepthStencilStateCreateInfo const* ptr() const {
-        return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo const*>(this);
+    safe_VkPipelineTessellationStateCreateInfo(const safe_VkPipelineTessellationStateCreateInfo& copy_src);
+    safe_VkPipelineTessellationStateCreateInfo& operator=(const safe_VkPipelineTessellationStateCreateInfo& copy_src);
+    safe_VkPipelineTessellationStateCreateInfo();
+    ~safe_VkPipelineTessellationStateCreateInfo();
+    void initialize(const VkPipelineTessellationStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineTessellationStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineTessellationStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineTessellationStateCreateInfo*>(this); }
+    VkPipelineTessellationStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineTessellationStateCreateInfo const*>(this);
     }
 };
-struct safe_VkPipelineColorBlendStateCreateInfo {
+struct safe_VkPipelineVertexInputStateCreateInfo {
     VkStructureType sType;
     const void* pNext{};
-    VkPipelineColorBlendStateCreateFlags flags;
-    VkBool32 logicOpEnable;
-    VkLogicOp logicOp;
-    uint32_t attachmentCount;
-    const VkPipelineColorBlendAttachmentState* pAttachments{};
-    float blendConstants[4];
+    VkPipelineVertexInputStateCreateFlags flags;
+    uint32_t vertexBindingDescriptionCount;
+    const VkVertexInputBindingDescription* pVertexBindingDescriptions{};
+    uint32_t vertexAttributeDescriptionCount;
+    const VkVertexInputAttributeDescription* pVertexAttributeDescriptions{};
 
-    safe_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo* in_struct, PNextCopyState* copy_state = {},
-                                             bool copy_pnext = true);
-    safe_VkPipelineColorBlendStateCreateInfo(const safe_VkPipelineColorBlendStateCreateInfo& copy_src);
-    safe_VkPipelineColorBlendStateCreateInfo& operator=(const safe_VkPipelineColorBlendStateCreateInfo& copy_src);
-    safe_VkPipelineColorBlendStateCreateInfo();
-    ~safe_VkPipelineColorBlendStateCreateInfo();
-    void initialize(const VkPipelineColorBlendStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPipelineColorBlendStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
-    VkPipelineColorBlendStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(this); }
-    VkPipelineColorBlendStateCreateInfo const* ptr() const {
-        return reinterpret_cast<VkPipelineColorBlendStateCreateInfo const*>(this);
+    safe_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineVertexInputStateCreateInfo(const safe_VkPipelineVertexInputStateCreateInfo& copy_src);
+    safe_VkPipelineVertexInputStateCreateInfo& operator=(const safe_VkPipelineVertexInputStateCreateInfo& copy_src);
+    safe_VkPipelineVertexInputStateCreateInfo();
+    ~safe_VkPipelineVertexInputStateCreateInfo();
+    void initialize(const VkPipelineVertexInputStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineVertexInputStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineVertexInputStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>(this); }
+    VkPipelineVertexInputStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineVertexInputStateCreateInfo const*>(this);
     }
 };
-struct safe_VkPipelineDynamicStateCreateInfo {
+struct safe_VkPipelineViewportStateCreateInfo {
     VkStructureType sType;
     const void* pNext{};
-    VkPipelineDynamicStateCreateFlags flags;
-    uint32_t dynamicStateCount;
-    const VkDynamicState* pDynamicStates{};
+    VkPipelineViewportStateCreateFlags flags;
+    uint32_t viewportCount;
+    const VkViewport* pViewports{};
+    uint32_t scissorCount;
+    const VkRect2D* pScissors{};
 
-    safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct, PNextCopyState* copy_state = {},
-                                          bool copy_pnext = true);
-    safe_VkPipelineDynamicStateCreateInfo(const safe_VkPipelineDynamicStateCreateInfo& copy_src);
-    safe_VkPipelineDynamicStateCreateInfo& operator=(const safe_VkPipelineDynamicStateCreateInfo& copy_src);
-    safe_VkPipelineDynamicStateCreateInfo();
-    ~safe_VkPipelineDynamicStateCreateInfo();
-    void initialize(const VkPipelineDynamicStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPipelineDynamicStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
-    VkPipelineDynamicStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineDynamicStateCreateInfo*>(this); }
-    VkPipelineDynamicStateCreateInfo const* ptr() const { return reinterpret_cast<VkPipelineDynamicStateCreateInfo const*>(this); }
+    safe_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports,
+                                           const bool is_dynamic_scissors, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineViewportStateCreateInfo(const safe_VkPipelineViewportStateCreateInfo& copy_src);
+    safe_VkPipelineViewportStateCreateInfo& operator=(const safe_VkPipelineViewportStateCreateInfo& copy_src);
+    safe_VkPipelineViewportStateCreateInfo();
+    ~safe_VkPipelineViewportStateCreateInfo();
+    void initialize(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports,
+                    const bool is_dynamic_scissors, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineViewportStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineViewportStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineViewportStateCreateInfo*>(this); }
+    VkPipelineViewportStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineViewportStateCreateInfo const*>(this);
+    }
 };
 struct safe_VkGraphicsPipelineCreateInfo {
     VkStructureType sType;
@@ -2285,6 +2285,25 @@ struct safe_VkPhysicalDeviceShaderDrawParametersFeatures {
         return reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceDriverProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkDriverId driverID;
+    char driverName[VK_MAX_DRIVER_NAME_SIZE];
+    char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
+    VkConformanceVersion conformanceVersion;
+
+    safe_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkPhysicalDeviceDriverProperties(const safe_VkPhysicalDeviceDriverProperties& copy_src);
+    safe_VkPhysicalDeviceDriverProperties& operator=(const safe_VkPhysicalDeviceDriverProperties& copy_src);
+    safe_VkPhysicalDeviceDriverProperties();
+    ~safe_VkPhysicalDeviceDriverProperties();
+    void initialize(const VkPhysicalDeviceDriverProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDriverProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDriverProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceDriverProperties*>(this); }
+    VkPhysicalDeviceDriverProperties const* ptr() const { return reinterpret_cast<VkPhysicalDeviceDriverProperties const*>(this); }
+};
 struct safe_VkPhysicalDeviceVulkan11Features {
     VkStructureType sType;
     void* pNext{};
@@ -2492,25 +2511,6 @@ struct safe_VkImageFormatListCreateInfo {
     VkImageFormatListCreateInfo* ptr() { return reinterpret_cast<VkImageFormatListCreateInfo*>(this); }
     VkImageFormatListCreateInfo const* ptr() const { return reinterpret_cast<VkImageFormatListCreateInfo const*>(this); }
 };
-struct safe_VkPhysicalDeviceDriverProperties {
-    VkStructureType sType;
-    void* pNext{};
-    VkDriverId driverID;
-    char driverName[VK_MAX_DRIVER_NAME_SIZE];
-    char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
-    VkConformanceVersion conformanceVersion;
-
-    safe_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties* in_struct, PNextCopyState* copy_state = {},
-                                          bool copy_pnext = true);
-    safe_VkPhysicalDeviceDriverProperties(const safe_VkPhysicalDeviceDriverProperties& copy_src);
-    safe_VkPhysicalDeviceDriverProperties& operator=(const safe_VkPhysicalDeviceDriverProperties& copy_src);
-    safe_VkPhysicalDeviceDriverProperties();
-    ~safe_VkPhysicalDeviceDriverProperties();
-    void initialize(const VkPhysicalDeviceDriverProperties* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceDriverProperties* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceDriverProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceDriverProperties*>(this); }
-    VkPhysicalDeviceDriverProperties const* ptr() const { return reinterpret_cast<VkPhysicalDeviceDriverProperties const*>(this); }
-};
 struct safe_VkPhysicalDeviceVulkanMemoryModelFeatures {
     VkStructureType sType;
     void* pNext{};
@@ -3176,29 +3176,6 @@ struct safe_VkSubpassDependency2 {
     VkSubpassDependency2* ptr() { return reinterpret_cast<VkSubpassDependency2*>(this); }
     VkSubpassDependency2 const* ptr() const { return reinterpret_cast<VkSubpassDependency2 const*>(this); }
 };
-struct safe_VkRenderPassCreateInfo2 {
-    VkStructureType sType;
-    const void* pNext{};
-    VkRenderPassCreateFlags flags;
-    uint32_t attachmentCount;
-    safe_VkAttachmentDescription2* pAttachments{};
-    uint32_t subpassCount;
-    safe_VkSubpassDescription2* pSubpasses{};
-    uint32_t dependencyCount;
-    safe_VkSubpassDependency2* pDependencies{};
-    uint32_t correlatedViewMaskCount;
-    const uint32_t* pCorrelatedViewMasks{};
-
-    safe_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkRenderPassCreateInfo2(const safe_VkRenderPassCreateInfo2& copy_src);
-    safe_VkRenderPassCreateInfo2& operator=(const safe_VkRenderPassCreateInfo2& copy_src);
-    safe_VkRenderPassCreateInfo2();
-    ~safe_VkRenderPassCreateInfo2();
-    void initialize(const VkRenderPassCreateInfo2* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkRenderPassCreateInfo2* copy_src, PNextCopyState* copy_state = {});
-    VkRenderPassCreateInfo2* ptr() { return reinterpret_cast<VkRenderPassCreateInfo2*>(this); }
-    VkRenderPassCreateInfo2 const* ptr() const { return reinterpret_cast<VkRenderPassCreateInfo2 const*>(this); }
-};
 struct safe_VkSubpassBeginInfo {
     VkStructureType sType;
     const void* pNext{};
@@ -3228,6 +3205,29 @@ struct safe_VkSubpassEndInfo {
     VkSubpassEndInfo* ptr() { return reinterpret_cast<VkSubpassEndInfo*>(this); }
     VkSubpassEndInfo const* ptr() const { return reinterpret_cast<VkSubpassEndInfo const*>(this); }
 };
+struct safe_VkRenderPassCreateInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderPassCreateFlags flags;
+    uint32_t attachmentCount;
+    safe_VkAttachmentDescription2* pAttachments{};
+    uint32_t subpassCount;
+    safe_VkSubpassDescription2* pSubpasses{};
+    uint32_t dependencyCount;
+    safe_VkSubpassDependency2* pDependencies{};
+    uint32_t correlatedViewMaskCount;
+    const uint32_t* pCorrelatedViewMasks{};
+
+    safe_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderPassCreateInfo2(const safe_VkRenderPassCreateInfo2& copy_src);
+    safe_VkRenderPassCreateInfo2& operator=(const safe_VkRenderPassCreateInfo2& copy_src);
+    safe_VkRenderPassCreateInfo2();
+    ~safe_VkRenderPassCreateInfo2();
+    void initialize(const VkRenderPassCreateInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassCreateInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassCreateInfo2* ptr() { return reinterpret_cast<VkRenderPassCreateInfo2*>(this); }
+    VkRenderPassCreateInfo2 const* ptr() const { return reinterpret_cast<VkRenderPassCreateInfo2 const*>(this); }
+};
 struct safe_VkSubpassDescriptionDepthStencilResolve {
     VkStructureType sType;
     const void* pNext{};
@@ -3330,6 +3330,23 @@ struct safe_VkFramebufferAttachmentImageInfo {
     VkFramebufferAttachmentImageInfo* ptr() { return reinterpret_cast<VkFramebufferAttachmentImageInfo*>(this); }
     VkFramebufferAttachmentImageInfo const* ptr() const { return reinterpret_cast<VkFramebufferAttachmentImageInfo const*>(this); }
 };
+struct safe_VkRenderPassAttachmentBeginInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t attachmentCount;
+    VkImageView* pAttachments{};
+
+    safe_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkRenderPassAttachmentBeginInfo(const safe_VkRenderPassAttachmentBeginInfo& copy_src);
+    safe_VkRenderPassAttachmentBeginInfo& operator=(const safe_VkRenderPassAttachmentBeginInfo& copy_src);
+    safe_VkRenderPassAttachmentBeginInfo();
+    ~safe_VkRenderPassAttachmentBeginInfo();
+    void initialize(const VkRenderPassAttachmentBeginInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassAttachmentBeginInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassAttachmentBeginInfo* ptr() { return reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(this); }
+    VkRenderPassAttachmentBeginInfo const* ptr() const { return reinterpret_cast<VkRenderPassAttachmentBeginInfo const*>(this); }
+};
 struct safe_VkFramebufferAttachmentsCreateInfo {
     VkStructureType sType;
     const void* pNext{};
@@ -3349,23 +3366,6 @@ struct safe_VkFramebufferAttachmentsCreateInfo {
         return reinterpret_cast<VkFramebufferAttachmentsCreateInfo const*>(this);
     }
 };
-struct safe_VkRenderPassAttachmentBeginInfo {
-    VkStructureType sType;
-    const void* pNext{};
-    uint32_t attachmentCount;
-    VkImageView* pAttachments{};
-
-    safe_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo* in_struct, PNextCopyState* copy_state = {},
-                                         bool copy_pnext = true);
-    safe_VkRenderPassAttachmentBeginInfo(const safe_VkRenderPassAttachmentBeginInfo& copy_src);
-    safe_VkRenderPassAttachmentBeginInfo& operator=(const safe_VkRenderPassAttachmentBeginInfo& copy_src);
-    safe_VkRenderPassAttachmentBeginInfo();
-    ~safe_VkRenderPassAttachmentBeginInfo();
-    void initialize(const VkRenderPassAttachmentBeginInfo* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkRenderPassAttachmentBeginInfo* copy_src, PNextCopyState* copy_state = {});
-    VkRenderPassAttachmentBeginInfo* ptr() { return reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(this); }
-    VkRenderPassAttachmentBeginInfo const* ptr() const { return reinterpret_cast<VkRenderPassAttachmentBeginInfo const*>(this); }
-};
 struct safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {
     VkStructureType sType;
     void* pNext{};
@@ -4774,6 +4774,21 @@ struct safe_VkPhysicalDeviceMaintenance5Properties {
         return reinterpret_cast<VkPhysicalDeviceMaintenance5Properties const*>(this);
     }
 };
+struct safe_VkSubresourceLayout2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkSubresourceLayout subresourceLayout;
+
+    safe_VkSubresourceLayout2(const VkSubresourceLayout2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSubresourceLayout2(const safe_VkSubresourceLayout2& copy_src);
+    safe_VkSubresourceLayout2& operator=(const safe_VkSubresourceLayout2& copy_src);
+    safe_VkSubresourceLayout2();
+    ~safe_VkSubresourceLayout2();
+    void initialize(const VkSubresourceLayout2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubresourceLayout2* copy_src, PNextCopyState* copy_state = {});
+    VkSubresourceLayout2* ptr() { return reinterpret_cast<VkSubresourceLayout2*>(this); }
+    VkSubresourceLayout2 const* ptr() const { return reinterpret_cast<VkSubresourceLayout2 const*>(this); }
+};
 struct safe_VkImageSubresource2 {
     VkStructureType sType;
     void* pNext{};
@@ -4806,21 +4821,6 @@ struct safe_VkDeviceImageSubresourceInfo {
     VkDeviceImageSubresourceInfo* ptr() { return reinterpret_cast<VkDeviceImageSubresourceInfo*>(this); }
     VkDeviceImageSubresourceInfo const* ptr() const { return reinterpret_cast<VkDeviceImageSubresourceInfo const*>(this); }
 };
-struct safe_VkSubresourceLayout2 {
-    VkStructureType sType;
-    void* pNext{};
-    VkSubresourceLayout subresourceLayout;
-
-    safe_VkSubresourceLayout2(const VkSubresourceLayout2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkSubresourceLayout2(const safe_VkSubresourceLayout2& copy_src);
-    safe_VkSubresourceLayout2& operator=(const safe_VkSubresourceLayout2& copy_src);
-    safe_VkSubresourceLayout2();
-    ~safe_VkSubresourceLayout2();
-    void initialize(const VkSubresourceLayout2* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkSubresourceLayout2* copy_src, PNextCopyState* copy_state = {});
-    VkSubresourceLayout2* ptr() { return reinterpret_cast<VkSubresourceLayout2*>(this); }
-    VkSubresourceLayout2 const* ptr() const { return reinterpret_cast<VkSubresourceLayout2 const*>(this); }
-};
 struct safe_VkBufferUsageFlags2CreateInfo {
     VkStructureType sType;
     const void* pNext{};
@@ -23700,8 +23700,8 @@ struct safe_VkUbmSurfaceCreateInfoSEC {
     VkStructureType sType;
     const void* pNext{};
     VkUbmSurfaceCreateFlagsSEC flags;
-    struct ubm_device* ubm_device{};
-    struct ubm_surface* ubm_surface{};
+    struct ubm_device* device{};
+    struct ubm_surface* surface{};
 
     safe_VkUbmSurfaceCreateInfoSEC(const VkUbmSurfaceCreateInfoSEC* in_struct, PNextCopyState* copy_state = {},
                                    bool copy_pnext = true);
@@ -23715,6 +23715,32 @@ struct safe_VkUbmSurfaceCreateInfoSEC {
     VkUbmSurfaceCreateInfoSEC const* ptr() const { return reinterpret_cast<VkUbmSurfaceCreateInfoSEC const*>(this); }
 };
 #endif  // VK_USE_PLATFORM_UBM_SEC
+struct safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderMixedFloatDotProductFloat16AccFloat32;
+    VkBool32 shaderMixedFloatDotProductFloat16AccFloat16;
+    VkBool32 shaderMixedFloatDotProductBFloat16Acc;
+    VkBool32 shaderMixedFloatDotProductFloat8AccFloat32;
+
+    safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE(
+        const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE(
+        const safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE& copy_src);
+    safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE& operator=(
+        const safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE& copy_src);
+    safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE();
+    ~safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE();
+    void initialize(const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE*>(this);
+    }
+    VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE const*>(this);
+    }
+};
 struct safe_VkAccelerationStructureGeometryTrianglesDataKHR {
     VkStructureType sType;
     const void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 55aa94b..abd41fa 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -18,9 +18,6 @@ VkStructureType GetSType() {
     static_assert(sizeof(T) == 0, "GetSType() is being used with an unsupported Type! Is the code-gen up to date?");
     return VK_STRUCTURE_TYPE_APPLICATION_INFO;
 }
-template <> inline VkStructureType GetSType<VkBufferMemoryBarrier>() { return VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; }
-template <> inline VkStructureType GetSType<VkImageMemoryBarrier>() { return VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; }
-template <> inline VkStructureType GetSType<VkMemoryBarrier>() { return VK_STRUCTURE_TYPE_MEMORY_BARRIER; }
 template <> inline VkStructureType GetSType<VkApplicationInfo>() { return VK_STRUCTURE_TYPE_APPLICATION_INFO; }
 template <> inline VkStructureType GetSType<VkInstanceCreateInfo>() { return VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; }
 template <> inline VkStructureType GetSType<VkDeviceQueueCreateInfo>() { return VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; }
@@ -39,6 +36,9 @@ template <> inline VkStructureType GetSType<VkCommandPoolCreateInfo>() { return
 template <> inline VkStructureType GetSType<VkCommandBufferAllocateInfo>() { return VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; }
 template <> inline VkStructureType GetSType<VkCommandBufferInheritanceInfo>() { return VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; }
 template <> inline VkStructureType GetSType<VkCommandBufferBeginInfo>() { return VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; }
+template <> inline VkStructureType GetSType<VkBufferMemoryBarrier>() { return VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; }
+template <> inline VkStructureType GetSType<VkImageMemoryBarrier>() { return VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; }
+template <> inline VkStructureType GetSType<VkMemoryBarrier>() { return VK_STRUCTURE_TYPE_MEMORY_BARRIER; }
 template <> inline VkStructureType GetSType<VkEventCreateInfo>() { return VK_STRUCTURE_TYPE_EVENT_CREATE_INFO; }
 template <> inline VkStructureType GetSType<VkBufferViewCreateInfo>() { return VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO; }
 template <> inline VkStructureType GetSType<VkShaderModuleCreateInfo>() { return VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; }
@@ -52,15 +52,15 @@ template <> inline VkStructureType GetSType<VkDescriptorPoolCreateInfo>() { retu
 template <> inline VkStructureType GetSType<VkDescriptorSetAllocateInfo>() { return VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; }
 template <> inline VkStructureType GetSType<VkDescriptorSetLayoutCreateInfo>() { return VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; }
 template <> inline VkStructureType GetSType<VkWriteDescriptorSet>() { return VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; }
-template <> inline VkStructureType GetSType<VkPipelineVertexInputStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkPipelineColorBlendStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkPipelineDepthStencilStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkPipelineDynamicStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; }
 template <> inline VkStructureType GetSType<VkPipelineInputAssemblyStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkPipelineMultisampleStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkPipelineRasterizationStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; }
 template <> inline VkStructureType GetSType<VkPipelineTessellationStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkPipelineVertexInputStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; }
 template <> inline VkStructureType GetSType<VkPipelineViewportStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; }
-template <> inline VkStructureType GetSType<VkPipelineRasterizationStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; }
-template <> inline VkStructureType GetSType<VkPipelineMultisampleStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; }
-template <> inline VkStructureType GetSType<VkPipelineDepthStencilStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; }
-template <> inline VkStructureType GetSType<VkPipelineColorBlendStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; }
-template <> inline VkStructureType GetSType<VkPipelineDynamicStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; }
 template <> inline VkStructureType GetSType<VkGraphicsPipelineCreateInfo>() { return VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; }
 template <> inline VkStructureType GetSType<VkFramebufferCreateInfo>() { return VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; }
 template <> inline VkStructureType GetSType<VkRenderPassCreateInfo>() { return VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; }
@@ -130,12 +130,12 @@ template <> inline VkStructureType GetSType<VkRenderPassMultiviewCreateInfo>() {
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMultiviewFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMultiviewProperties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderDrawParametersFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceDriverProperties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVulkan11Features>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVulkan11Properties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVulkan12Features>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVulkan12Properties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES; }
 template <> inline VkStructureType GetSType<VkImageFormatListCreateInfo>() { return VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceDriverProperties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVulkanMemoryModelFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceHostQueryResetFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceTimelineSemaphoreFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; }
@@ -167,16 +167,16 @@ template <> inline VkStructureType GetSType<VkAttachmentDescription2>() { return
 template <> inline VkStructureType GetSType<VkAttachmentReference2>() { return VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2; }
 template <> inline VkStructureType GetSType<VkSubpassDescription2>() { return VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2; }
 template <> inline VkStructureType GetSType<VkSubpassDependency2>() { return VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2; }
-template <> inline VkStructureType GetSType<VkRenderPassCreateInfo2>() { return VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2; }
 template <> inline VkStructureType GetSType<VkSubpassBeginInfo>() { return VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO; }
 template <> inline VkStructureType GetSType<VkSubpassEndInfo>() { return VK_STRUCTURE_TYPE_SUBPASS_END_INFO; }
+template <> inline VkStructureType GetSType<VkRenderPassCreateInfo2>() { return VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2; }
 template <> inline VkStructureType GetSType<VkSubpassDescriptionDepthStencilResolve>() { return VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDepthStencilResolveProperties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; }
 template <> inline VkStructureType GetSType<VkImageStencilUsageCreateInfo>() { return VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceImagelessFramebufferFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; }
 template <> inline VkStructureType GetSType<VkFramebufferAttachmentImageInfo>() { return VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO; }
-template <> inline VkStructureType GetSType<VkFramebufferAttachmentsCreateInfo>() { return VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO; }
 template <> inline VkStructureType GetSType<VkRenderPassAttachmentBeginInfo>() { return VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO; }
+template <> inline VkStructureType GetSType<VkFramebufferAttachmentsCreateInfo>() { return VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; }
 template <> inline VkStructureType GetSType<VkAttachmentReferenceStencilLayout>() { return VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT; }
 template <> inline VkStructureType GetSType<VkAttachmentDescriptionStencilLayout>() { return VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT; }
@@ -242,9 +242,9 @@ template <> inline VkStructureType GetSType<VkMemoryMapInfo>() { return VK_STRUC
 template <> inline VkStructureType GetSType<VkMemoryUnmapInfo>() { return VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance5Features>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance5Properties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkSubresourceLayout2>() { return VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2; }
 template <> inline VkStructureType GetSType<VkImageSubresource2>() { return VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2; }
 template <> inline VkStructureType GetSType<VkDeviceImageSubresourceInfo>() { return VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO; }
-template <> inline VkStructureType GetSType<VkSubresourceLayout2>() { return VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2; }
 template <> inline VkStructureType GetSType<VkBufferUsageFlags2CreateInfo>() { return VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance6Features>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance6Properties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES; }
@@ -1227,6 +1227,7 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderSubgroupPartit
 #ifdef VK_USE_PLATFORM_UBM_SEC
 template <> inline VkStructureType GetSType<VkUbmSurfaceCreateInfoSEC>() { return VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC; }
 #endif  // VK_USE_PLATFORM_UBM_SEC
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryInstancesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; }
@@ -1322,8 +1323,6 @@ template<typename T> VkObjectType GetObjectType() {
     return VK_OBJECT_TYPE_UNKNOWN;
 }
 
-template<> inline VkObjectType GetObjectType<VkBuffer>() { return VK_OBJECT_TYPE_BUFFER; }
-template<> inline VkObjectType GetObjectType<VkImage>() { return VK_OBJECT_TYPE_IMAGE; }
 template<> inline VkObjectType GetObjectType<VkInstance>() { return VK_OBJECT_TYPE_INSTANCE; }
 template<> inline VkObjectType GetObjectType<VkPhysicalDevice>() { return VK_OBJECT_TYPE_PHYSICAL_DEVICE; }
 template<> inline VkObjectType GetObjectType<VkDevice>() { return VK_OBJECT_TYPE_DEVICE; }
@@ -1332,6 +1331,8 @@ template<> inline VkObjectType GetObjectType<VkSemaphore>() { return VK_OBJECT_T
 template<> inline VkObjectType GetObjectType<VkCommandBuffer>() { return VK_OBJECT_TYPE_COMMAND_BUFFER; }
 template<> inline VkObjectType GetObjectType<VkFence>() { return VK_OBJECT_TYPE_FENCE; }
 template<> inline VkObjectType GetObjectType<VkDeviceMemory>() { return VK_OBJECT_TYPE_DEVICE_MEMORY; }
+template<> inline VkObjectType GetObjectType<VkBuffer>() { return VK_OBJECT_TYPE_BUFFER; }
+template<> inline VkObjectType GetObjectType<VkImage>() { return VK_OBJECT_TYPE_IMAGE; }
 template<> inline VkObjectType GetObjectType<VkQueryPool>() { return VK_OBJECT_TYPE_QUERY_POOL; }
 template<> inline VkObjectType GetObjectType<VkImageView>() { return VK_OBJECT_TYPE_IMAGE_VIEW; }
 template<> inline VkObjectType GetObjectType<VkCommandPool>() { return VK_OBJECT_TYPE_COMMAND_POOL; }
@@ -1341,8 +1342,8 @@ template<> inline VkObjectType GetObjectType<VkEvent>() { return VK_OBJECT_TYPE_
 template<> inline VkObjectType GetObjectType<VkBufferView>() { return VK_OBJECT_TYPE_BUFFER_VIEW; }
 template<> inline VkObjectType GetObjectType<VkShaderModule>() { return VK_OBJECT_TYPE_SHADER_MODULE; }
 template<> inline VkObjectType GetObjectType<VkPipelineCache>() { return VK_OBJECT_TYPE_PIPELINE_CACHE; }
-template<> inline VkObjectType GetObjectType<VkPipelineLayout>() { return VK_OBJECT_TYPE_PIPELINE_LAYOUT; }
 template<> inline VkObjectType GetObjectType<VkPipeline>() { return VK_OBJECT_TYPE_PIPELINE; }
+template<> inline VkObjectType GetObjectType<VkPipelineLayout>() { return VK_OBJECT_TYPE_PIPELINE_LAYOUT; }
 template<> inline VkObjectType GetObjectType<VkDescriptorSetLayout>() { return VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT; }
 template<> inline VkObjectType GetObjectType<VkSampler>() { return VK_OBJECT_TYPE_SAMPLER; }
 template<> inline VkObjectType GetObjectType<VkDescriptorSet>() { return VK_OBJECT_TYPE_DESCRIPTOR_SET; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 65963b4..9a1fe74 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -350,6 +350,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
@@ -360,8 +362,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES";
         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
             return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
@@ -2464,80 +2464,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC:
             return "VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE";
         default:
             return "Unhandled VkStructureType";
     }
 }
-static inline const char* string_VkImageLayout(VkImageLayout input_value) {
-    switch (input_value) {
-        case VK_IMAGE_LAYOUT_UNDEFINED:
-            return "VK_IMAGE_LAYOUT_UNDEFINED";
-        case VK_IMAGE_LAYOUT_GENERAL:
-            return "VK_IMAGE_LAYOUT_GENERAL";
-        case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
-            return "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
-        case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
-            return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
-        case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
-            return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
-        case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
-            return "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
-        case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
-            return "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL";
-        case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
-            return "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL";
-        case VK_IMAGE_LAYOUT_PREINITIALIZED:
-            return "VK_IMAGE_LAYOUT_PREINITIALIZED";
-        case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL:
-            return "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL";
-        case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL:
-            return "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL";
-        case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL:
-            return "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL";
-        case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL:
-            return "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL";
-        case VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL:
-            return "VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL";
-        case VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL:
-            return "VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL";
-        case VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL:
-            return "VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL";
-        case VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL:
-            return "VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL";
-        case VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ:
-            return "VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ";
-        case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
-            return "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR";
-        case VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR:
-            return "VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR";
-        case VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR:
-            return "VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR";
-        case VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR:
-            return "VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR";
-        case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR:
-            return "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR";
-        case VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT:
-            return "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT";
-        case VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR:
-            return "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR";
-        case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR:
-            return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR";
-        case VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR:
-            return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR";
-        case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR:
-            return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR";
-        case VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT:
-            return "VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT";
-        case VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM:
-            return "VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM";
-        case VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR:
-            return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR";
-        case VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT:
-            return "VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT";
-        default:
-            return "Unhandled VkImageLayout";
-    }
-}
 static inline const char* string_VkObjectType(VkObjectType input_value) {
     switch (input_value) {
         case VK_OBJECT_TYPE_UNKNOWN:
@@ -3400,6 +3332,76 @@ static inline const char* string_VkSharingMode(VkSharingMode input_value) {
             return "Unhandled VkSharingMode";
     }
 }
+static inline const char* string_VkImageLayout(VkImageLayout input_value) {
+    switch (input_value) {
+        case VK_IMAGE_LAYOUT_UNDEFINED:
+            return "VK_IMAGE_LAYOUT_UNDEFINED";
+        case VK_IMAGE_LAYOUT_GENERAL:
+            return "VK_IMAGE_LAYOUT_GENERAL";
+        case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+            return "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
+        case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+            return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
+        case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+            return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
+        case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+            return "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
+        case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
+            return "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL";
+        case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
+            return "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL";
+        case VK_IMAGE_LAYOUT_PREINITIALIZED:
+            return "VK_IMAGE_LAYOUT_PREINITIALIZED";
+        case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL:
+            return "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL";
+        case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL:
+            return "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL";
+        case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL:
+            return "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL";
+        case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL:
+            return "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL";
+        case VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL:
+            return "VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL";
+        case VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL:
+            return "VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL";
+        case VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL:
+            return "VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL";
+        case VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL:
+            return "VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL";
+        case VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ:
+            return "VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ";
+        case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
+            return "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR";
+        case VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR:
+            return "VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR";
+        case VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR:
+            return "VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR";
+        case VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR:
+            return "VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR";
+        case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR:
+            return "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR";
+        case VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT:
+            return "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT";
+        case VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR:
+            return "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR";
+        case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR:
+            return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR";
+        case VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR:
+            return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR";
+        case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR:
+            return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR";
+        case VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT:
+            return "VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT";
+        case VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM:
+            return "VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM";
+        case VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR:
+            return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR";
+        case VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT:
+            return "VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT";
+        default:
+            return "Unhandled VkImageLayout";
+    }
+}
 static inline const char* string_VkComponentSwizzle(VkComponentSwizzle input_value) {
     switch (input_value) {
         case VK_COMPONENT_SWIZZLE_IDENTITY:
@@ -3524,16 +3526,6 @@ static inline const char* string_VkSamplerAddressMode(VkSamplerAddressMode input
             return "Unhandled VkSamplerAddressMode";
     }
 }
-static inline const char* string_VkSamplerMipmapMode(VkSamplerMipmapMode input_value) {
-    switch (input_value) {
-        case VK_SAMPLER_MIPMAP_MODE_NEAREST:
-            return "VK_SAMPLER_MIPMAP_MODE_NEAREST";
-        case VK_SAMPLER_MIPMAP_MODE_LINEAR:
-            return "VK_SAMPLER_MIPMAP_MODE_LINEAR";
-        default:
-            return "Unhandled VkSamplerMipmapMode";
-    }
-}
 static inline const char* string_VkCompareOp(VkCompareOp input_value) {
     switch (input_value) {
         case VK_COMPARE_OP_NEVER:
@@ -3556,6 +3548,16 @@ static inline const char* string_VkCompareOp(VkCompareOp input_value) {
             return "Unhandled VkCompareOp";
     }
 }
+static inline const char* string_VkSamplerMipmapMode(VkSamplerMipmapMode input_value) {
+    switch (input_value) {
+        case VK_SAMPLER_MIPMAP_MODE_NEAREST:
+            return "VK_SAMPLER_MIPMAP_MODE_NEAREST";
+        case VK_SAMPLER_MIPMAP_MODE_LINEAR:
+            return "VK_SAMPLER_MIPMAP_MODE_LINEAR";
+        default:
+            return "Unhandled VkSamplerMipmapMode";
+    }
+}
 static inline const char* string_VkDescriptorType(VkDescriptorType input_value) {
     switch (input_value) {
         case VK_DESCRIPTOR_TYPE_SAMPLER:
@@ -3934,6 +3936,66 @@ static inline const char* string_VkFrontFace(VkFrontFace input_value) {
             return "Unhandled VkFrontFace";
     }
 }
+static inline const char* string_VkLogicOp(VkLogicOp input_value) {
+    switch (input_value) {
+        case VK_LOGIC_OP_CLEAR:
+            return "VK_LOGIC_OP_CLEAR";
+        case VK_LOGIC_OP_AND:
+            return "VK_LOGIC_OP_AND";
+        case VK_LOGIC_OP_AND_REVERSE:
+            return "VK_LOGIC_OP_AND_REVERSE";
+        case VK_LOGIC_OP_COPY:
+            return "VK_LOGIC_OP_COPY";
+        case VK_LOGIC_OP_AND_INVERTED:
+            return "VK_LOGIC_OP_AND_INVERTED";
+        case VK_LOGIC_OP_NO_OP:
+            return "VK_LOGIC_OP_NO_OP";
+        case VK_LOGIC_OP_XOR:
+            return "VK_LOGIC_OP_XOR";
+        case VK_LOGIC_OP_OR:
+            return "VK_LOGIC_OP_OR";
+        case VK_LOGIC_OP_NOR:
+            return "VK_LOGIC_OP_NOR";
+        case VK_LOGIC_OP_EQUIVALENT:
+            return "VK_LOGIC_OP_EQUIVALENT";
+        case VK_LOGIC_OP_INVERT:
+            return "VK_LOGIC_OP_INVERT";
+        case VK_LOGIC_OP_OR_REVERSE:
+            return "VK_LOGIC_OP_OR_REVERSE";
+        case VK_LOGIC_OP_COPY_INVERTED:
+            return "VK_LOGIC_OP_COPY_INVERTED";
+        case VK_LOGIC_OP_OR_INVERTED:
+            return "VK_LOGIC_OP_OR_INVERTED";
+        case VK_LOGIC_OP_NAND:
+            return "VK_LOGIC_OP_NAND";
+        case VK_LOGIC_OP_SET:
+            return "VK_LOGIC_OP_SET";
+        default:
+            return "Unhandled VkLogicOp";
+    }
+}
+static inline const char* string_VkStencilOp(VkStencilOp input_value) {
+    switch (input_value) {
+        case VK_STENCIL_OP_KEEP:
+            return "VK_STENCIL_OP_KEEP";
+        case VK_STENCIL_OP_ZERO:
+            return "VK_STENCIL_OP_ZERO";
+        case VK_STENCIL_OP_REPLACE:
+            return "VK_STENCIL_OP_REPLACE";
+        case VK_STENCIL_OP_INCREMENT_AND_CLAMP:
+            return "VK_STENCIL_OP_INCREMENT_AND_CLAMP";
+        case VK_STENCIL_OP_DECREMENT_AND_CLAMP:
+            return "VK_STENCIL_OP_DECREMENT_AND_CLAMP";
+        case VK_STENCIL_OP_INVERT:
+            return "VK_STENCIL_OP_INVERT";
+        case VK_STENCIL_OP_INCREMENT_AND_WRAP:
+            return "VK_STENCIL_OP_INCREMENT_AND_WRAP";
+        case VK_STENCIL_OP_DECREMENT_AND_WRAP:
+            return "VK_STENCIL_OP_DECREMENT_AND_WRAP";
+        default:
+            return "Unhandled VkStencilOp";
+    }
+}
 static inline const char* string_VkVertexInputRate(VkVertexInputRate input_value) {
     switch (input_value) {
         case VK_VERTEX_INPUT_RATE_VERTEX:
@@ -3986,81 +4048,21 @@ static inline const char* string_VkPolygonMode(VkPolygonMode input_value) {
             return "Unhandled VkPolygonMode";
     }
 }
-static inline const char* string_VkStencilOp(VkStencilOp input_value) {
+static inline const char* string_VkAttachmentLoadOp(VkAttachmentLoadOp input_value) {
     switch (input_value) {
-        case VK_STENCIL_OP_KEEP:
-            return "VK_STENCIL_OP_KEEP";
-        case VK_STENCIL_OP_ZERO:
-            return "VK_STENCIL_OP_ZERO";
-        case VK_STENCIL_OP_REPLACE:
-            return "VK_STENCIL_OP_REPLACE";
-        case VK_STENCIL_OP_INCREMENT_AND_CLAMP:
-            return "VK_STENCIL_OP_INCREMENT_AND_CLAMP";
-        case VK_STENCIL_OP_DECREMENT_AND_CLAMP:
-            return "VK_STENCIL_OP_DECREMENT_AND_CLAMP";
-        case VK_STENCIL_OP_INVERT:
-            return "VK_STENCIL_OP_INVERT";
-        case VK_STENCIL_OP_INCREMENT_AND_WRAP:
-            return "VK_STENCIL_OP_INCREMENT_AND_WRAP";
-        case VK_STENCIL_OP_DECREMENT_AND_WRAP:
-            return "VK_STENCIL_OP_DECREMENT_AND_WRAP";
+        case VK_ATTACHMENT_LOAD_OP_LOAD:
+            return "VK_ATTACHMENT_LOAD_OP_LOAD";
+        case VK_ATTACHMENT_LOAD_OP_CLEAR:
+            return "VK_ATTACHMENT_LOAD_OP_CLEAR";
+        case VK_ATTACHMENT_LOAD_OP_DONT_CARE:
+            return "VK_ATTACHMENT_LOAD_OP_DONT_CARE";
+        case VK_ATTACHMENT_LOAD_OP_NONE:
+            return "VK_ATTACHMENT_LOAD_OP_NONE";
         default:
-            return "Unhandled VkStencilOp";
+            return "Unhandled VkAttachmentLoadOp";
     }
 }
-static inline const char* string_VkLogicOp(VkLogicOp input_value) {
-    switch (input_value) {
-        case VK_LOGIC_OP_CLEAR:
-            return "VK_LOGIC_OP_CLEAR";
-        case VK_LOGIC_OP_AND:
-            return "VK_LOGIC_OP_AND";
-        case VK_LOGIC_OP_AND_REVERSE:
-            return "VK_LOGIC_OP_AND_REVERSE";
-        case VK_LOGIC_OP_COPY:
-            return "VK_LOGIC_OP_COPY";
-        case VK_LOGIC_OP_AND_INVERTED:
-            return "VK_LOGIC_OP_AND_INVERTED";
-        case VK_LOGIC_OP_NO_OP:
-            return "VK_LOGIC_OP_NO_OP";
-        case VK_LOGIC_OP_XOR:
-            return "VK_LOGIC_OP_XOR";
-        case VK_LOGIC_OP_OR:
-            return "VK_LOGIC_OP_OR";
-        case VK_LOGIC_OP_NOR:
-            return "VK_LOGIC_OP_NOR";
-        case VK_LOGIC_OP_EQUIVALENT:
-            return "VK_LOGIC_OP_EQUIVALENT";
-        case VK_LOGIC_OP_INVERT:
-            return "VK_LOGIC_OP_INVERT";
-        case VK_LOGIC_OP_OR_REVERSE:
-            return "VK_LOGIC_OP_OR_REVERSE";
-        case VK_LOGIC_OP_COPY_INVERTED:
-            return "VK_LOGIC_OP_COPY_INVERTED";
-        case VK_LOGIC_OP_OR_INVERTED:
-            return "VK_LOGIC_OP_OR_INVERTED";
-        case VK_LOGIC_OP_NAND:
-            return "VK_LOGIC_OP_NAND";
-        case VK_LOGIC_OP_SET:
-            return "VK_LOGIC_OP_SET";
-        default:
-            return "Unhandled VkLogicOp";
-    }
-}
-static inline const char* string_VkAttachmentLoadOp(VkAttachmentLoadOp input_value) {
-    switch (input_value) {
-        case VK_ATTACHMENT_LOAD_OP_LOAD:
-            return "VK_ATTACHMENT_LOAD_OP_LOAD";
-        case VK_ATTACHMENT_LOAD_OP_CLEAR:
-            return "VK_ATTACHMENT_LOAD_OP_CLEAR";
-        case VK_ATTACHMENT_LOAD_OP_DONT_CARE:
-            return "VK_ATTACHMENT_LOAD_OP_DONT_CARE";
-        case VK_ATTACHMENT_LOAD_OP_NONE:
-            return "VK_ATTACHMENT_LOAD_OP_NONE";
-        default:
-            return "Unhandled VkAttachmentLoadOp";
-    }
-}
-static inline const char* string_VkAttachmentStoreOp(VkAttachmentStoreOp input_value) {
+static inline const char* string_VkAttachmentStoreOp(VkAttachmentStoreOp input_value) {
     switch (input_value) {
         case VK_ATTACHMENT_STORE_OP_STORE:
             return "VK_ATTACHMENT_STORE_OP_STORE";
@@ -4084,6 +4086,16 @@ static inline const char* string_VkSubpassContents(VkSubpassContents input_value
             return "Unhandled VkSubpassContents";
     }
 }
+static inline const char* string_VkPointClippingBehavior(VkPointClippingBehavior input_value) {
+    switch (input_value) {
+        case VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES:
+            return "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES";
+        case VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY:
+            return "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY";
+        default:
+            return "Unhandled VkPointClippingBehavior";
+    }
+}
 static inline const char* string_VkDescriptorUpdateTemplateType(VkDescriptorUpdateTemplateType input_value) {
     switch (input_value) {
         case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET:
@@ -4130,16 +4142,6 @@ static inline const char* string_VkChromaLocation(VkChromaLocation input_value)
             return "Unhandled VkChromaLocation";
     }
 }
-static inline const char* string_VkPointClippingBehavior(VkPointClippingBehavior input_value) {
-    switch (input_value) {
-        case VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES:
-            return "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES";
-        case VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY:
-            return "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY";
-        default:
-            return "Unhandled VkPointClippingBehavior";
-    }
-}
 static inline const char* string_VkTessellationDomainOrigin(VkTessellationDomainOrigin input_value) {
     switch (input_value) {
         case VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT:
@@ -5837,134 +5839,6 @@ static inline const char* string_VkShaderGroupShaderKHR(VkShaderGroupShaderKHR i
     }
 }
 
-static inline const char* string_VkAccessFlagBits(VkAccessFlagBits input_value) {
-    switch (input_value) {
-        case VK_ACCESS_INDIRECT_COMMAND_READ_BIT:
-            return "VK_ACCESS_INDIRECT_COMMAND_READ_BIT";
-        case VK_ACCESS_INDEX_READ_BIT:
-            return "VK_ACCESS_INDEX_READ_BIT";
-        case VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT:
-            return "VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT";
-        case VK_ACCESS_UNIFORM_READ_BIT:
-            return "VK_ACCESS_UNIFORM_READ_BIT";
-        case VK_ACCESS_INPUT_ATTACHMENT_READ_BIT:
-            return "VK_ACCESS_INPUT_ATTACHMENT_READ_BIT";
-        case VK_ACCESS_SHADER_READ_BIT:
-            return "VK_ACCESS_SHADER_READ_BIT";
-        case VK_ACCESS_SHADER_WRITE_BIT:
-            return "VK_ACCESS_SHADER_WRITE_BIT";
-        case VK_ACCESS_COLOR_ATTACHMENT_READ_BIT:
-            return "VK_ACCESS_COLOR_ATTACHMENT_READ_BIT";
-        case VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT:
-            return "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT";
-        case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT:
-            return "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT";
-        case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT:
-            return "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT";
-        case VK_ACCESS_TRANSFER_READ_BIT:
-            return "VK_ACCESS_TRANSFER_READ_BIT";
-        case VK_ACCESS_TRANSFER_WRITE_BIT:
-            return "VK_ACCESS_TRANSFER_WRITE_BIT";
-        case VK_ACCESS_HOST_READ_BIT:
-            return "VK_ACCESS_HOST_READ_BIT";
-        case VK_ACCESS_HOST_WRITE_BIT:
-            return "VK_ACCESS_HOST_WRITE_BIT";
-        case VK_ACCESS_MEMORY_READ_BIT:
-            return "VK_ACCESS_MEMORY_READ_BIT";
-        case VK_ACCESS_MEMORY_WRITE_BIT:
-            return "VK_ACCESS_MEMORY_WRITE_BIT";
-        case VK_ACCESS_NONE:
-            return "VK_ACCESS_NONE";
-        case VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT:
-            return "VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT";
-        case VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT:
-            return "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT";
-        case VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT:
-            return "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT";
-        case VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT:
-            return "VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT";
-        case VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT:
-            return "VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT";
-        case VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR:
-            return "VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR";
-        case VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR:
-            return "VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR";
-        case VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT:
-            return "VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT";
-        case VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR:
-            return "VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR";
-        case VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT:
-            return "VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT";
-        case VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT:
-            return "VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT";
-        default:
-            return "Unhandled VkAccessFlagBits";
-    }
-}
-
-#ifdef __cplusplus
-static inline std::string string_VkAccessFlags(VkAccessFlags input_value) {
-    std::string ret;
-    int index = 0;
-    while(input_value) {
-        if (input_value & 1) {
-            if( !ret.empty()) ret.append("|");
-            ret.append(string_VkAccessFlagBits(static_cast<VkAccessFlagBits>(1U << index)));
-        }
-        ++index;
-        input_value >>= 1;
-    }
-    if (ret.empty()) ret.append("VkAccessFlags(0)");
-    return ret;
-}
-#endif // __cplusplus
-static inline const char* string_VkImageAspectFlagBits(VkImageAspectFlagBits input_value) {
-    switch (input_value) {
-        case VK_IMAGE_ASPECT_COLOR_BIT:
-            return "VK_IMAGE_ASPECT_COLOR_BIT";
-        case VK_IMAGE_ASPECT_DEPTH_BIT:
-            return "VK_IMAGE_ASPECT_DEPTH_BIT";
-        case VK_IMAGE_ASPECT_STENCIL_BIT:
-            return "VK_IMAGE_ASPECT_STENCIL_BIT";
-        case VK_IMAGE_ASPECT_METADATA_BIT:
-            return "VK_IMAGE_ASPECT_METADATA_BIT";
-        case VK_IMAGE_ASPECT_PLANE_0_BIT:
-            return "VK_IMAGE_ASPECT_PLANE_0_BIT";
-        case VK_IMAGE_ASPECT_PLANE_1_BIT:
-            return "VK_IMAGE_ASPECT_PLANE_1_BIT";
-        case VK_IMAGE_ASPECT_PLANE_2_BIT:
-            return "VK_IMAGE_ASPECT_PLANE_2_BIT";
-        case VK_IMAGE_ASPECT_NONE:
-            return "VK_IMAGE_ASPECT_NONE";
-        case VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT:
-            return "VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT";
-        case VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT:
-            return "VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT";
-        case VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT:
-            return "VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT";
-        case VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT:
-            return "VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT";
-        default:
-            return "Unhandled VkImageAspectFlagBits";
-    }
-}
-
-#ifdef __cplusplus
-static inline std::string string_VkImageAspectFlags(VkImageAspectFlags input_value) {
-    std::string ret;
-    int index = 0;
-    while(input_value) {
-        if (input_value & 1) {
-            if( !ret.empty()) ret.append("|");
-            ret.append(string_VkImageAspectFlagBits(static_cast<VkImageAspectFlagBits>(1U << index)));
-        }
-        ++index;
-        input_value >>= 1;
-    }
-    if (ret.empty()) ret.append("VkImageAspectFlags(0)");
-    return ret;
-}
-#endif // __cplusplus
 static inline const char* string_VkFormatFeatureFlagBits(VkFormatFeatureFlagBits input_value) {
     switch (input_value) {
         case VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT:
@@ -6359,6 +6233,63 @@ static inline std::string string_VkQueueFlags(VkQueueFlags input_value) {
     return ret;
 }
 #endif // __cplusplus
+static inline const char* string_VkShaderStageFlagBits(VkShaderStageFlagBits input_value) {
+    switch (input_value) {
+        case VK_SHADER_STAGE_VERTEX_BIT:
+            return "VK_SHADER_STAGE_VERTEX_BIT";
+        case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
+            return "VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT";
+        case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
+            return "VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT";
+        case VK_SHADER_STAGE_GEOMETRY_BIT:
+            return "VK_SHADER_STAGE_GEOMETRY_BIT";
+        case VK_SHADER_STAGE_FRAGMENT_BIT:
+            return "VK_SHADER_STAGE_FRAGMENT_BIT";
+        case VK_SHADER_STAGE_COMPUTE_BIT:
+            return "VK_SHADER_STAGE_COMPUTE_BIT";
+        case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
+            return "VK_SHADER_STAGE_RAYGEN_BIT_KHR";
+        case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
+            return "VK_SHADER_STAGE_ANY_HIT_BIT_KHR";
+        case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
+            return "VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR";
+        case VK_SHADER_STAGE_MISS_BIT_KHR:
+            return "VK_SHADER_STAGE_MISS_BIT_KHR";
+        case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
+            return "VK_SHADER_STAGE_INTERSECTION_BIT_KHR";
+        case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
+            return "VK_SHADER_STAGE_CALLABLE_BIT_KHR";
+        case VK_SHADER_STAGE_TASK_BIT_EXT:
+            return "VK_SHADER_STAGE_TASK_BIT_EXT";
+        case VK_SHADER_STAGE_MESH_BIT_EXT:
+            return "VK_SHADER_STAGE_MESH_BIT_EXT";
+        case VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI:
+            return "VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI";
+        case VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI:
+            return "VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI";
+        default:
+            return "Unhandled VkShaderStageFlagBits";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkShaderStageFlags(VkShaderStageFlags input_value) {
+    if (input_value == VK_SHADER_STAGE_ALL_GRAPHICS) { return "VK_SHADER_STAGE_ALL_GRAPHICS"; }
+    if (input_value == VK_SHADER_STAGE_ALL) { return "VK_SHADER_STAGE_ALL"; }
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkShaderStageFlagBits(static_cast<VkShaderStageFlagBits>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkShaderStageFlags(0)");
+    return ret;
+}
+#endif // __cplusplus
 static inline const char* string_VkDeviceQueueCreateFlagBits(VkDeviceQueueCreateFlagBits input_value) {
     switch (input_value) {
         case VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT:
@@ -6488,28 +6419,50 @@ static inline std::string string_VkMemoryMapFlags(VkMemoryMapFlags input_value)
     return ret;
 }
 #endif // __cplusplus
-static inline const char* string_VkSparseMemoryBindFlagBits(VkSparseMemoryBindFlagBits input_value) {
+static inline const char* string_VkImageAspectFlagBits(VkImageAspectFlagBits input_value) {
     switch (input_value) {
-        case VK_SPARSE_MEMORY_BIND_METADATA_BIT:
-            return "VK_SPARSE_MEMORY_BIND_METADATA_BIT";
+        case VK_IMAGE_ASPECT_COLOR_BIT:
+            return "VK_IMAGE_ASPECT_COLOR_BIT";
+        case VK_IMAGE_ASPECT_DEPTH_BIT:
+            return "VK_IMAGE_ASPECT_DEPTH_BIT";
+        case VK_IMAGE_ASPECT_STENCIL_BIT:
+            return "VK_IMAGE_ASPECT_STENCIL_BIT";
+        case VK_IMAGE_ASPECT_METADATA_BIT:
+            return "VK_IMAGE_ASPECT_METADATA_BIT";
+        case VK_IMAGE_ASPECT_PLANE_0_BIT:
+            return "VK_IMAGE_ASPECT_PLANE_0_BIT";
+        case VK_IMAGE_ASPECT_PLANE_1_BIT:
+            return "VK_IMAGE_ASPECT_PLANE_1_BIT";
+        case VK_IMAGE_ASPECT_PLANE_2_BIT:
+            return "VK_IMAGE_ASPECT_PLANE_2_BIT";
+        case VK_IMAGE_ASPECT_NONE:
+            return "VK_IMAGE_ASPECT_NONE";
+        case VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT:
+            return "VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT";
+        case VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT:
+            return "VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT";
+        case VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT:
+            return "VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT";
+        case VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT:
+            return "VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT";
         default:
-            return "Unhandled VkSparseMemoryBindFlagBits";
+            return "Unhandled VkImageAspectFlagBits";
     }
 }
 
 #ifdef __cplusplus
-static inline std::string string_VkSparseMemoryBindFlags(VkSparseMemoryBindFlags input_value) {
+static inline std::string string_VkImageAspectFlags(VkImageAspectFlags input_value) {
     std::string ret;
     int index = 0;
     while(input_value) {
         if (input_value & 1) {
             if( !ret.empty()) ret.append("|");
-            ret.append(string_VkSparseMemoryBindFlagBits(static_cast<VkSparseMemoryBindFlagBits>(1U << index)));
+            ret.append(string_VkImageAspectFlagBits(static_cast<VkImageAspectFlagBits>(1U << index)));
         }
         ++index;
         input_value >>= 1;
     }
-    if (ret.empty()) ret.append("VkSparseMemoryBindFlags(0)");
+    if (ret.empty()) ret.append("VkImageAspectFlags(0)");
     return ret;
 }
 #endif // __cplusplus
@@ -6542,6 +6495,31 @@ static inline std::string string_VkSparseImageFormatFlags(VkSparseImageFormatFla
     return ret;
 }
 #endif // __cplusplus
+static inline const char* string_VkSparseMemoryBindFlagBits(VkSparseMemoryBindFlagBits input_value) {
+    switch (input_value) {
+        case VK_SPARSE_MEMORY_BIND_METADATA_BIT:
+            return "VK_SPARSE_MEMORY_BIND_METADATA_BIT";
+        default:
+            return "Unhandled VkSparseMemoryBindFlagBits";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkSparseMemoryBindFlags(VkSparseMemoryBindFlags input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkSparseMemoryBindFlagBits(static_cast<VkSparseMemoryBindFlagBits>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkSparseMemoryBindFlags(0)");
+    return ret;
+}
+#endif // __cplusplus
 static inline const char* string_VkFenceCreateFlagBits(VkFenceCreateFlagBits input_value) {
     switch (input_value) {
         case VK_FENCE_CREATE_SIGNALED_BIT:
@@ -6823,6 +6801,87 @@ static inline std::string string_VkImageViewCreateFlags(VkImageViewCreateFlags i
     return ret;
 }
 #endif // __cplusplus
+static inline const char* string_VkAccessFlagBits(VkAccessFlagBits input_value) {
+    switch (input_value) {
+        case VK_ACCESS_INDIRECT_COMMAND_READ_BIT:
+            return "VK_ACCESS_INDIRECT_COMMAND_READ_BIT";
+        case VK_ACCESS_INDEX_READ_BIT:
+            return "VK_ACCESS_INDEX_READ_BIT";
+        case VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT:
+            return "VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT";
+        case VK_ACCESS_UNIFORM_READ_BIT:
+            return "VK_ACCESS_UNIFORM_READ_BIT";
+        case VK_ACCESS_INPUT_ATTACHMENT_READ_BIT:
+            return "VK_ACCESS_INPUT_ATTACHMENT_READ_BIT";
+        case VK_ACCESS_SHADER_READ_BIT:
+            return "VK_ACCESS_SHADER_READ_BIT";
+        case VK_ACCESS_SHADER_WRITE_BIT:
+            return "VK_ACCESS_SHADER_WRITE_BIT";
+        case VK_ACCESS_COLOR_ATTACHMENT_READ_BIT:
+            return "VK_ACCESS_COLOR_ATTACHMENT_READ_BIT";
+        case VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT:
+            return "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT";
+        case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT:
+            return "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT";
+        case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT:
+            return "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT";
+        case VK_ACCESS_TRANSFER_READ_BIT:
+            return "VK_ACCESS_TRANSFER_READ_BIT";
+        case VK_ACCESS_TRANSFER_WRITE_BIT:
+            return "VK_ACCESS_TRANSFER_WRITE_BIT";
+        case VK_ACCESS_HOST_READ_BIT:
+            return "VK_ACCESS_HOST_READ_BIT";
+        case VK_ACCESS_HOST_WRITE_BIT:
+            return "VK_ACCESS_HOST_WRITE_BIT";
+        case VK_ACCESS_MEMORY_READ_BIT:
+            return "VK_ACCESS_MEMORY_READ_BIT";
+        case VK_ACCESS_MEMORY_WRITE_BIT:
+            return "VK_ACCESS_MEMORY_WRITE_BIT";
+        case VK_ACCESS_NONE:
+            return "VK_ACCESS_NONE";
+        case VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT:
+            return "VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT";
+        case VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT:
+            return "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT";
+        case VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT:
+            return "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT";
+        case VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT:
+            return "VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT";
+        case VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT:
+            return "VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT";
+        case VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR:
+            return "VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR";
+        case VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR:
+            return "VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR";
+        case VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT:
+            return "VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT";
+        case VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR:
+            return "VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR";
+        case VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT:
+            return "VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT";
+        case VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT:
+            return "VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT";
+        default:
+            return "Unhandled VkAccessFlagBits";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkAccessFlags(VkAccessFlags input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkAccessFlagBits(static_cast<VkAccessFlagBits>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkAccessFlags(0)");
+    return ret;
+}
+#endif // __cplusplus
 static inline const char* string_VkDependencyFlagBits(VkDependencyFlagBits input_value) {
     switch (input_value) {
         case VK_DEPENDENCY_BY_REGION_BIT:
@@ -6912,57 +6971,57 @@ static inline std::string string_VkCommandPoolResetFlags(VkCommandPoolResetFlags
     return ret;
 }
 #endif // __cplusplus
-static inline const char* string_VkCommandBufferUsageFlagBits(VkCommandBufferUsageFlagBits input_value) {
+static inline const char* string_VkQueryControlFlagBits(VkQueryControlFlagBits input_value) {
     switch (input_value) {
-        case VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT:
-            return "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT";
-        case VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT:
-            return "VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT";
-        case VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT:
-            return "VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT";
+        case VK_QUERY_CONTROL_PRECISE_BIT:
+            return "VK_QUERY_CONTROL_PRECISE_BIT";
         default:
-            return "Unhandled VkCommandBufferUsageFlagBits";
+            return "Unhandled VkQueryControlFlagBits";
     }
 }
 
 #ifdef __cplusplus
-static inline std::string string_VkCommandBufferUsageFlags(VkCommandBufferUsageFlags input_value) {
+static inline std::string string_VkQueryControlFlags(VkQueryControlFlags input_value) {
     std::string ret;
     int index = 0;
     while(input_value) {
         if (input_value & 1) {
             if( !ret.empty()) ret.append("|");
-            ret.append(string_VkCommandBufferUsageFlagBits(static_cast<VkCommandBufferUsageFlagBits>(1U << index)));
+            ret.append(string_VkQueryControlFlagBits(static_cast<VkQueryControlFlagBits>(1U << index)));
         }
         ++index;
         input_value >>= 1;
     }
-    if (ret.empty()) ret.append("VkCommandBufferUsageFlags(0)");
+    if (ret.empty()) ret.append("VkQueryControlFlags(0)");
     return ret;
 }
 #endif // __cplusplus
-static inline const char* string_VkQueryControlFlagBits(VkQueryControlFlagBits input_value) {
+static inline const char* string_VkCommandBufferUsageFlagBits(VkCommandBufferUsageFlagBits input_value) {
     switch (input_value) {
-        case VK_QUERY_CONTROL_PRECISE_BIT:
-            return "VK_QUERY_CONTROL_PRECISE_BIT";
+        case VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT:
+            return "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT";
+        case VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT:
+            return "VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT";
+        case VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT:
+            return "VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT";
         default:
-            return "Unhandled VkQueryControlFlagBits";
+            return "Unhandled VkCommandBufferUsageFlagBits";
     }
 }
 
 #ifdef __cplusplus
-static inline std::string string_VkQueryControlFlags(VkQueryControlFlags input_value) {
+static inline std::string string_VkCommandBufferUsageFlags(VkCommandBufferUsageFlags input_value) {
     std::string ret;
     int index = 0;
     while(input_value) {
         if (input_value & 1) {
             if( !ret.empty()) ret.append("|");
-            ret.append(string_VkQueryControlFlagBits(static_cast<VkQueryControlFlagBits>(1U << index)));
+            ret.append(string_VkCommandBufferUsageFlagBits(static_cast<VkCommandBufferUsageFlagBits>(1U << index)));
         }
         ++index;
         input_value >>= 1;
     }
-    if (ret.empty()) ret.append("VkQueryControlFlags(0)");
+    if (ret.empty()) ret.append("VkCommandBufferUsageFlags(0)");
     return ret;
 }
 #endif // __cplusplus
@@ -7097,145 +7156,88 @@ static inline const char* string_VkPipelineCreateFlagBits(VkPipelineCreateFlagBi
             return "VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT";
         case VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT:
             return "VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT";
-        case VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV:
-            return "VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV";
-        case VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT:
-            return "VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT";
-        case VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT:
-            return "VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT";
-        case VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT:
-            return "VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT";
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-        case VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV:
-            return "VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV";
-#endif  // VK_ENABLE_BETA_EXTENSIONS
-        default:
-            return "Unhandled VkPipelineCreateFlagBits";
-    }
-}
-
-#ifdef __cplusplus
-static inline std::string string_VkPipelineCreateFlags(VkPipelineCreateFlags input_value) {
-    std::string ret;
-    int index = 0;
-    while(input_value) {
-        if (input_value & 1) {
-            if( !ret.empty()) ret.append("|");
-            ret.append(string_VkPipelineCreateFlagBits(static_cast<VkPipelineCreateFlagBits>(1U << index)));
-        }
-        ++index;
-        input_value >>= 1;
-    }
-    if (ret.empty()) ret.append("VkPipelineCreateFlags(0)");
-    return ret;
-}
-#endif // __cplusplus
-static inline const char* string_VkPipelineShaderStageCreateFlagBits(VkPipelineShaderStageCreateFlagBits input_value) {
-    switch (input_value) {
-        case VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT:
-            return "VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT";
-        case VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT:
-            return "VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT";
+        case VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV:
+            return "VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV";
+        case VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT:
+            return "VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT";
+        case VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT:
+            return "VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT";
+        case VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT:
+            return "VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT";
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV:
+            return "VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
         default:
-            return "Unhandled VkPipelineShaderStageCreateFlagBits";
+            return "Unhandled VkPipelineCreateFlagBits";
     }
 }
 
 #ifdef __cplusplus
-static inline std::string string_VkPipelineShaderStageCreateFlags(VkPipelineShaderStageCreateFlags input_value) {
+static inline std::string string_VkPipelineCreateFlags(VkPipelineCreateFlags input_value) {
     std::string ret;
     int index = 0;
     while(input_value) {
         if (input_value & 1) {
             if( !ret.empty()) ret.append("|");
-            ret.append(string_VkPipelineShaderStageCreateFlagBits(static_cast<VkPipelineShaderStageCreateFlagBits>(1U << index)));
+            ret.append(string_VkPipelineCreateFlagBits(static_cast<VkPipelineCreateFlagBits>(1U << index)));
         }
         ++index;
         input_value >>= 1;
     }
-    if (ret.empty()) ret.append("VkPipelineShaderStageCreateFlags(0)");
+    if (ret.empty()) ret.append("VkPipelineCreateFlags(0)");
     return ret;
 }
 #endif // __cplusplus
-static inline const char* string_VkShaderStageFlagBits(VkShaderStageFlagBits input_value) {
+static inline const char* string_VkPipelineLayoutCreateFlagBits(VkPipelineLayoutCreateFlagBits input_value) {
     switch (input_value) {
-        case VK_SHADER_STAGE_VERTEX_BIT:
-            return "VK_SHADER_STAGE_VERTEX_BIT";
-        case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
-            return "VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT";
-        case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
-            return "VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT";
-        case VK_SHADER_STAGE_GEOMETRY_BIT:
-            return "VK_SHADER_STAGE_GEOMETRY_BIT";
-        case VK_SHADER_STAGE_FRAGMENT_BIT:
-            return "VK_SHADER_STAGE_FRAGMENT_BIT";
-        case VK_SHADER_STAGE_COMPUTE_BIT:
-            return "VK_SHADER_STAGE_COMPUTE_BIT";
-        case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
-            return "VK_SHADER_STAGE_RAYGEN_BIT_KHR";
-        case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
-            return "VK_SHADER_STAGE_ANY_HIT_BIT_KHR";
-        case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
-            return "VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR";
-        case VK_SHADER_STAGE_MISS_BIT_KHR:
-            return "VK_SHADER_STAGE_MISS_BIT_KHR";
-        case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
-            return "VK_SHADER_STAGE_INTERSECTION_BIT_KHR";
-        case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
-            return "VK_SHADER_STAGE_CALLABLE_BIT_KHR";
-        case VK_SHADER_STAGE_TASK_BIT_EXT:
-            return "VK_SHADER_STAGE_TASK_BIT_EXT";
-        case VK_SHADER_STAGE_MESH_BIT_EXT:
-            return "VK_SHADER_STAGE_MESH_BIT_EXT";
-        case VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI:
-            return "VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI";
-        case VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI:
-            return "VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI";
+        case VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT:
+            return "VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT";
         default:
-            return "Unhandled VkShaderStageFlagBits";
+            return "Unhandled VkPipelineLayoutCreateFlagBits";
     }
 }
 
 #ifdef __cplusplus
-static inline std::string string_VkShaderStageFlags(VkShaderStageFlags input_value) {
-    if (input_value == VK_SHADER_STAGE_ALL_GRAPHICS) { return "VK_SHADER_STAGE_ALL_GRAPHICS"; }
-    if (input_value == VK_SHADER_STAGE_ALL) { return "VK_SHADER_STAGE_ALL"; }
+static inline std::string string_VkPipelineLayoutCreateFlags(VkPipelineLayoutCreateFlags input_value) {
     std::string ret;
     int index = 0;
     while(input_value) {
         if (input_value & 1) {
             if( !ret.empty()) ret.append("|");
-            ret.append(string_VkShaderStageFlagBits(static_cast<VkShaderStageFlagBits>(1U << index)));
+            ret.append(string_VkPipelineLayoutCreateFlagBits(static_cast<VkPipelineLayoutCreateFlagBits>(1U << index)));
         }
         ++index;
         input_value >>= 1;
     }
-    if (ret.empty()) ret.append("VkShaderStageFlags(0)");
+    if (ret.empty()) ret.append("VkPipelineLayoutCreateFlags(0)");
     return ret;
 }
 #endif // __cplusplus
-static inline const char* string_VkPipelineLayoutCreateFlagBits(VkPipelineLayoutCreateFlagBits input_value) {
+static inline const char* string_VkPipelineShaderStageCreateFlagBits(VkPipelineShaderStageCreateFlagBits input_value) {
     switch (input_value) {
-        case VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT:
-            return "VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT";
+        case VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT:
+            return "VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT";
+        case VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT:
+            return "VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT";
         default:
-            return "Unhandled VkPipelineLayoutCreateFlagBits";
+            return "Unhandled VkPipelineShaderStageCreateFlagBits";
     }
 }
 
 #ifdef __cplusplus
-static inline std::string string_VkPipelineLayoutCreateFlags(VkPipelineLayoutCreateFlags input_value) {
+static inline std::string string_VkPipelineShaderStageCreateFlags(VkPipelineShaderStageCreateFlags input_value) {
     std::string ret;
     int index = 0;
     while(input_value) {
         if (input_value & 1) {
             if( !ret.empty()) ret.append("|");
-            ret.append(string_VkPipelineLayoutCreateFlagBits(static_cast<VkPipelineLayoutCreateFlagBits>(1U << index)));
+            ret.append(string_VkPipelineShaderStageCreateFlagBits(static_cast<VkPipelineShaderStageCreateFlagBits>(1U << index)));
         }
         ++index;
         input_value >>= 1;
     }
-    if (ret.empty()) ret.append("VkPipelineLayoutCreateFlags(0)");
+    if (ret.empty()) ret.append("VkPipelineShaderStageCreateFlags(0)");
     return ret;
 }
 #endif // __cplusplus
@@ -7403,55 +7405,55 @@ static inline std::string string_VkCullModeFlags(VkCullModeFlags input_value) {
     return ret;
 }
 #endif // __cplusplus
-static inline const char* string_VkPipelineDepthStencilStateCreateFlagBits(VkPipelineDepthStencilStateCreateFlagBits input_value) {
+static inline const char* string_VkPipelineColorBlendStateCreateFlagBits(VkPipelineColorBlendStateCreateFlagBits input_value) {
     switch (input_value) {
-        case VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT:
-            return "VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT";
-        case VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT:
-            return "VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT";
+        case VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT:
+            return "VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT";
         default:
-            return "Unhandled VkPipelineDepthStencilStateCreateFlagBits";
+            return "Unhandled VkPipelineColorBlendStateCreateFlagBits";
     }
 }
 
 #ifdef __cplusplus
-static inline std::string string_VkPipelineDepthStencilStateCreateFlags(VkPipelineDepthStencilStateCreateFlags input_value) {
+static inline std::string string_VkPipelineColorBlendStateCreateFlags(VkPipelineColorBlendStateCreateFlags input_value) {
     std::string ret;
     int index = 0;
     while(input_value) {
         if (input_value & 1) {
             if( !ret.empty()) ret.append("|");
-            ret.append(string_VkPipelineDepthStencilStateCreateFlagBits(static_cast<VkPipelineDepthStencilStateCreateFlagBits>(1U << index)));
+            ret.append(string_VkPipelineColorBlendStateCreateFlagBits(static_cast<VkPipelineColorBlendStateCreateFlagBits>(1U << index)));
         }
         ++index;
         input_value >>= 1;
     }
-    if (ret.empty()) ret.append("VkPipelineDepthStencilStateCreateFlags(0)");
+    if (ret.empty()) ret.append("VkPipelineColorBlendStateCreateFlags(0)");
     return ret;
 }
 #endif // __cplusplus
-static inline const char* string_VkPipelineColorBlendStateCreateFlagBits(VkPipelineColorBlendStateCreateFlagBits input_value) {
+static inline const char* string_VkPipelineDepthStencilStateCreateFlagBits(VkPipelineDepthStencilStateCreateFlagBits input_value) {
     switch (input_value) {
-        case VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT:
-            return "VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT";
+        case VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT:
+            return "VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT";
+        case VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT:
+            return "VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT";
         default:
-            return "Unhandled VkPipelineColorBlendStateCreateFlagBits";
+            return "Unhandled VkPipelineDepthStencilStateCreateFlagBits";
     }
 }
 
 #ifdef __cplusplus
-static inline std::string string_VkPipelineColorBlendStateCreateFlags(VkPipelineColorBlendStateCreateFlags input_value) {
+static inline std::string string_VkPipelineDepthStencilStateCreateFlags(VkPipelineDepthStencilStateCreateFlags input_value) {
     std::string ret;
     int index = 0;
     while(input_value) {
         if (input_value & 1) {
             if( !ret.empty()) ret.append("|");
-            ret.append(string_VkPipelineColorBlendStateCreateFlagBits(static_cast<VkPipelineColorBlendStateCreateFlagBits>(1U << index)));
+            ret.append(string_VkPipelineDepthStencilStateCreateFlagBits(static_cast<VkPipelineDepthStencilStateCreateFlagBits>(1U << index)));
         }
         ++index;
         input_value >>= 1;
     }
-    if (ret.empty()) ret.append("VkPipelineColorBlendStateCreateFlags(0)");
+    if (ret.empty()) ret.append("VkPipelineDepthStencilStateCreateFlags(0)");
     return ret;
 }
 #endif // __cplusplus
@@ -7605,6 +7607,51 @@ static inline std::string string_VkStencilFaceFlags(VkStencilFaceFlags input_val
     return ret;
 }
 #endif // __cplusplus
+static inline const char* string_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlagBits input_value) {
+    switch (input_value) {
+        case VK_SUBGROUP_FEATURE_BASIC_BIT:
+            return "VK_SUBGROUP_FEATURE_BASIC_BIT";
+        case VK_SUBGROUP_FEATURE_VOTE_BIT:
+            return "VK_SUBGROUP_FEATURE_VOTE_BIT";
+        case VK_SUBGROUP_FEATURE_ARITHMETIC_BIT:
+            return "VK_SUBGROUP_FEATURE_ARITHMETIC_BIT";
+        case VK_SUBGROUP_FEATURE_BALLOT_BIT:
+            return "VK_SUBGROUP_FEATURE_BALLOT_BIT";
+        case VK_SUBGROUP_FEATURE_SHUFFLE_BIT:
+            return "VK_SUBGROUP_FEATURE_SHUFFLE_BIT";
+        case VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT:
+            return "VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT";
+        case VK_SUBGROUP_FEATURE_CLUSTERED_BIT:
+            return "VK_SUBGROUP_FEATURE_CLUSTERED_BIT";
+        case VK_SUBGROUP_FEATURE_QUAD_BIT:
+            return "VK_SUBGROUP_FEATURE_QUAD_BIT";
+        case VK_SUBGROUP_FEATURE_ROTATE_BIT:
+            return "VK_SUBGROUP_FEATURE_ROTATE_BIT";
+        case VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT:
+            return "VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT";
+        case VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT:
+            return "VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT";
+        default:
+            return "Unhandled VkSubgroupFeatureFlagBits";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkSubgroupFeatureFlags(VkSubgroupFeatureFlags input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkSubgroupFeatureFlagBits(static_cast<VkSubgroupFeatureFlagBits>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkSubgroupFeatureFlags(0)");
+    return ret;
+}
+#endif // __cplusplus
 static inline const char* string_VkPeerMemoryFeatureFlagBits(VkPeerMemoryFeatureFlagBits input_value) {
     switch (input_value) {
         case VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT:
@@ -7925,51 +7972,6 @@ static inline std::string string_VkExternalSemaphoreFeatureFlags(VkExternalSemap
     return ret;
 }
 #endif // __cplusplus
-static inline const char* string_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlagBits input_value) {
-    switch (input_value) {
-        case VK_SUBGROUP_FEATURE_BASIC_BIT:
-            return "VK_SUBGROUP_FEATURE_BASIC_BIT";
-        case VK_SUBGROUP_FEATURE_VOTE_BIT:
-            return "VK_SUBGROUP_FEATURE_VOTE_BIT";
-        case VK_SUBGROUP_FEATURE_ARITHMETIC_BIT:
-            return "VK_SUBGROUP_FEATURE_ARITHMETIC_BIT";
-        case VK_SUBGROUP_FEATURE_BALLOT_BIT:
-            return "VK_SUBGROUP_FEATURE_BALLOT_BIT";
-        case VK_SUBGROUP_FEATURE_SHUFFLE_BIT:
-            return "VK_SUBGROUP_FEATURE_SHUFFLE_BIT";
-        case VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT:
-            return "VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT";
-        case VK_SUBGROUP_FEATURE_CLUSTERED_BIT:
-            return "VK_SUBGROUP_FEATURE_CLUSTERED_BIT";
-        case VK_SUBGROUP_FEATURE_QUAD_BIT:
-            return "VK_SUBGROUP_FEATURE_QUAD_BIT";
-        case VK_SUBGROUP_FEATURE_ROTATE_BIT:
-            return "VK_SUBGROUP_FEATURE_ROTATE_BIT";
-        case VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT:
-            return "VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT";
-        case VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT:
-            return "VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT";
-        default:
-            return "Unhandled VkSubgroupFeatureFlagBits";
-    }
-}
-
-#ifdef __cplusplus
-static inline std::string string_VkSubgroupFeatureFlags(VkSubgroupFeatureFlags input_value) {
-    std::string ret;
-    int index = 0;
-    while(input_value) {
-        if (input_value & 1) {
-            if( !ret.empty()) ret.append("|");
-            ret.append(string_VkSubgroupFeatureFlagBits(static_cast<VkSubgroupFeatureFlagBits>(1U << index)));
-        }
-        ++index;
-        input_value >>= 1;
-    }
-    if (ret.empty()) ret.append("VkSubgroupFeatureFlags(0)");
-    return ret;
-}
-#endif // __cplusplus
 static inline const char* string_VkResolveModeFlagBits(VkResolveModeFlagBits input_value) {
     switch (input_value) {
         case VK_RESOLVE_MODE_NONE:
@@ -11427,12 +11429,6 @@ static inline std::string string_VkAccelerationStructureCreateFlagsKHR(VkAcceler
 // Same thing as string_VkStructureType, but prints out the API name
 static inline const char* string_VkStructureName(VkStructureType input_value) {
     switch (input_value) {
-        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
-            return "VkBufferMemoryBarrier";
-        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
-            return "VkImageMemoryBarrier";
-        case VK_STRUCTURE_TYPE_MEMORY_BARRIER:
-            return "VkMemoryBarrier";
         case VK_STRUCTURE_TYPE_APPLICATION_INFO:
             return "VkApplicationInfo";
         case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO:
@@ -11469,6 +11465,12 @@ static inline const char* string_VkStructureName(VkStructureType input_value) {
             return "VkCommandBufferInheritanceInfo";
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO:
             return "VkCommandBufferBeginInfo";
+        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
+            return "VkBufferMemoryBarrier";
+        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
+            return "VkImageMemoryBarrier";
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER:
+            return "VkMemoryBarrier";
         case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO:
             return "VkEventCreateInfo";
         case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
@@ -11495,24 +11497,24 @@ static inline const char* string_VkStructureName(VkStructureType input_value) {
             return "VkDescriptorSetLayoutCreateInfo";
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
             return "VkWriteDescriptorSet";
-        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO:
-            return "VkPipelineVertexInputStateCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO:
+            return "VkPipelineColorBlendStateCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO:
+            return "VkPipelineDepthStencilStateCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO:
+            return "VkPipelineDynamicStateCreateInfo";
         case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO:
             return "VkPipelineInputAssemblyStateCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO:
+            return "VkPipelineMultisampleStateCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:
+            return "VkPipelineRasterizationStateCreateInfo";
         case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO:
             return "VkPipelineTessellationStateCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO:
+            return "VkPipelineVertexInputStateCreateInfo";
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO:
             return "VkPipelineViewportStateCreateInfo";
-        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:
-            return "VkPipelineRasterizationStateCreateInfo";
-        case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO:
-            return "VkPipelineMultisampleStateCreateInfo";
-        case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO:
-            return "VkPipelineDepthStencilStateCreateInfo";
-        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO:
-            return "VkPipelineColorBlendStateCreateInfo";
-        case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO:
-            return "VkPipelineDynamicStateCreateInfo";
         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
             return "VkGraphicsPipelineCreateInfo";
         case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
@@ -11651,6 +11653,8 @@ static inline const char* string_VkStructureName(VkStructureType input_value) {
             return "VkPhysicalDeviceMultiviewProperties";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
             return "VkPhysicalDeviceShaderDrawParametersFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
+            return "VkPhysicalDeviceDriverProperties";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
             return "VkPhysicalDeviceVulkan11Features";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
@@ -11661,8 +11665,6 @@ static inline const char* string_VkStructureName(VkStructureType input_value) {
             return "VkPhysicalDeviceVulkan12Properties";
         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
             return "VkImageFormatListCreateInfo";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
-            return "VkPhysicalDeviceDriverProperties";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
             return "VkPhysicalDeviceVulkanMemoryModelFeatures";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
@@ -11725,12 +11727,12 @@ static inline const char* string_VkStructureName(VkStructureType input_value) {
             return "VkSubpassDescription2";
         case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2:
             return "VkSubpassDependency2";
-        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
-            return "VkRenderPassCreateInfo2";
         case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO:
             return "VkSubpassBeginInfo";
         case VK_STRUCTURE_TYPE_SUBPASS_END_INFO:
             return "VkSubpassEndInfo";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
+            return "VkRenderPassCreateInfo2";
         case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
             return "VkSubpassDescriptionDepthStencilResolve";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
@@ -11741,10 +11743,10 @@ static inline const char* string_VkStructureName(VkStructureType input_value) {
             return "VkPhysicalDeviceImagelessFramebufferFeatures";
         case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO:
             return "VkFramebufferAttachmentImageInfo";
-        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
-            return "VkFramebufferAttachmentsCreateInfo";
         case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
             return "VkRenderPassAttachmentBeginInfo";
+        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
+            return "VkFramebufferAttachmentsCreateInfo";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
             return "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures";
         case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
@@ -11875,12 +11877,12 @@ static inline const char* string_VkStructureName(VkStructureType input_value) {
             return "VkPhysicalDeviceMaintenance5Features";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES:
             return "VkPhysicalDeviceMaintenance5Properties";
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2:
+            return "VkSubresourceLayout2";
         case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2:
             return "VkImageSubresource2";
         case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO:
             return "VkDeviceImageSubresourceInfo";
-        case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2:
-            return "VkSubresourceLayout2";
         case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO:
             return "VkBufferUsageFlags2CreateInfo";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
@@ -13777,6 +13779,8 @@ static inline const char* string_VkStructureName(VkStructureType input_value) {
         case VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC:
             return "VkUbmSurfaceCreateInfoSEC";
 #endif  // VK_USE_PLATFORM_UBM_SEC
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE:
+            return "VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE";
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR:
             return "VkAccelerationStructureGeometryTrianglesDataKHR";
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 30db858..58c6d58 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.4.343"
+            "commit": "v1.4.344"
         },
         {
             "name": "googletest",
@@ -46,4 +46,4 @@
         "googletest": "GOOGLETEST_INSTALL_DIR",
         "magic_enum": "MAGIC_ENUM_INSTALL_DIR"
     }
-}
\ No newline at end of file
+}
diff --git a/src/vulkan/vk_safe_struct_core.cpp b/src/vulkan/vk_safe_struct_core.cpp
index eb31f00..d162e24 100644
--- a/src/vulkan/vk_safe_struct_core.cpp
+++ b/src/vulkan/vk_safe_struct_core.cpp
@@ -22,227 +22,6 @@
 
 namespace vku {
 
-safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct,
-                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      srcAccessMask(in_struct->srcAccessMask),
-      dstAccessMask(in_struct->dstAccessMask),
-      srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex),
-      dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex),
-      buffer(in_struct->buffer),
-      offset(in_struct->offset),
-      size(in_struct->size) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier()
-    : sType(VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER),
-      pNext(nullptr),
-      srcAccessMask(),
-      dstAccessMask(),
-      srcQueueFamilyIndex(),
-      dstQueueFamilyIndex(),
-      buffer(),
-      offset(),
-      size() {}
-
-safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& copy_src) {
-    sType = copy_src.sType;
-    srcAccessMask = copy_src.srcAccessMask;
-    dstAccessMask = copy_src.dstAccessMask;
-    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
-    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
-    buffer = copy_src.buffer;
-    offset = copy_src.offset;
-    size = copy_src.size;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkBufferMemoryBarrier& safe_VkBufferMemoryBarrier::operator=(const safe_VkBufferMemoryBarrier& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    srcAccessMask = copy_src.srcAccessMask;
-    dstAccessMask = copy_src.dstAccessMask;
-    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
-    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
-    buffer = copy_src.buffer;
-    offset = copy_src.offset;
-    size = copy_src.size;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkBufferMemoryBarrier::~safe_VkBufferMemoryBarrier() { FreePnextChain(pNext); }
-
-void safe_VkBufferMemoryBarrier::initialize(const VkBufferMemoryBarrier* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    srcAccessMask = in_struct->srcAccessMask;
-    dstAccessMask = in_struct->dstAccessMask;
-    srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex;
-    dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex;
-    buffer = in_struct->buffer;
-    offset = in_struct->offset;
-    size = in_struct->size;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkBufferMemoryBarrier::initialize(const safe_VkBufferMemoryBarrier* copy_src,
-                                            [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    srcAccessMask = copy_src->srcAccessMask;
-    dstAccessMask = copy_src->dstAccessMask;
-    srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex;
-    dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex;
-    buffer = copy_src->buffer;
-    offset = copy_src->offset;
-    size = copy_src->size;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* in_struct,
-                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      srcAccessMask(in_struct->srcAccessMask),
-      dstAccessMask(in_struct->dstAccessMask),
-      oldLayout(in_struct->oldLayout),
-      newLayout(in_struct->newLayout),
-      srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex),
-      dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex),
-      image(in_struct->image),
-      subresourceRange(in_struct->subresourceRange) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier()
-    : sType(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER),
-      pNext(nullptr),
-      srcAccessMask(),
-      dstAccessMask(),
-      oldLayout(),
-      newLayout(),
-      srcQueueFamilyIndex(),
-      dstQueueFamilyIndex(),
-      image(),
-      subresourceRange() {}
-
-safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& copy_src) {
-    sType = copy_src.sType;
-    srcAccessMask = copy_src.srcAccessMask;
-    dstAccessMask = copy_src.dstAccessMask;
-    oldLayout = copy_src.oldLayout;
-    newLayout = copy_src.newLayout;
-    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
-    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
-    image = copy_src.image;
-    subresourceRange = copy_src.subresourceRange;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkImageMemoryBarrier& safe_VkImageMemoryBarrier::operator=(const safe_VkImageMemoryBarrier& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    srcAccessMask = copy_src.srcAccessMask;
-    dstAccessMask = copy_src.dstAccessMask;
-    oldLayout = copy_src.oldLayout;
-    newLayout = copy_src.newLayout;
-    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
-    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
-    image = copy_src.image;
-    subresourceRange = copy_src.subresourceRange;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkImageMemoryBarrier::~safe_VkImageMemoryBarrier() { FreePnextChain(pNext); }
-
-void safe_VkImageMemoryBarrier::initialize(const VkImageMemoryBarrier* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    srcAccessMask = in_struct->srcAccessMask;
-    dstAccessMask = in_struct->dstAccessMask;
-    oldLayout = in_struct->oldLayout;
-    newLayout = in_struct->newLayout;
-    srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex;
-    dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex;
-    image = in_struct->image;
-    subresourceRange = in_struct->subresourceRange;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkImageMemoryBarrier::initialize(const safe_VkImageMemoryBarrier* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    srcAccessMask = copy_src->srcAccessMask;
-    dstAccessMask = copy_src->dstAccessMask;
-    oldLayout = copy_src->oldLayout;
-    newLayout = copy_src->newLayout;
-    srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex;
-    dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex;
-    image = copy_src->image;
-    subresourceRange = copy_src->subresourceRange;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkMemoryBarrier::safe_VkMemoryBarrier(const VkMemoryBarrier* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
-                                           bool copy_pnext)
-    : sType(in_struct->sType), srcAccessMask(in_struct->srcAccessMask), dstAccessMask(in_struct->dstAccessMask) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkMemoryBarrier::safe_VkMemoryBarrier()
-    : sType(VK_STRUCTURE_TYPE_MEMORY_BARRIER), pNext(nullptr), srcAccessMask(), dstAccessMask() {}
-
-safe_VkMemoryBarrier::safe_VkMemoryBarrier(const safe_VkMemoryBarrier& copy_src) {
-    sType = copy_src.sType;
-    srcAccessMask = copy_src.srcAccessMask;
-    dstAccessMask = copy_src.dstAccessMask;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkMemoryBarrier& safe_VkMemoryBarrier::operator=(const safe_VkMemoryBarrier& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    srcAccessMask = copy_src.srcAccessMask;
-    dstAccessMask = copy_src.dstAccessMask;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkMemoryBarrier::~safe_VkMemoryBarrier() { FreePnextChain(pNext); }
-
-void safe_VkMemoryBarrier::initialize(const VkMemoryBarrier* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    srcAccessMask = in_struct->srcAccessMask;
-    dstAccessMask = in_struct->dstAccessMask;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkMemoryBarrier::initialize(const safe_VkMemoryBarrier* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    srcAccessMask = copy_src->srcAccessMask;
-    dstAccessMask = copy_src->dstAccessMask;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkAllocationCallbacks::safe_VkAllocationCallbacks(const VkAllocationCallbacks* in_struct,
                                                        [[maybe_unused]] PNextCopyState* copy_state)
     : pUserData(in_struct->pUserData),
@@ -1184,41 +963,41 @@ void safe_VkMemoryAllocateInfo::initialize(const safe_VkMemoryAllocateInfo* copy
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* in_struct,
-                                                                     [[maybe_unused]] PNextCopyState* copy_state)
-    : buffer(in_struct->buffer), bindCount(in_struct->bindCount), pBinds(nullptr) {
+safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state)
+    : image(in_struct->image), bindCount(in_struct->bindCount), pBinds(nullptr) {
     if (bindCount && in_struct->pBinds) {
-        pBinds = new VkSparseMemoryBind[bindCount];
+        pBinds = new VkSparseImageMemoryBind[bindCount];
         for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = in_struct->pBinds[i];
         }
     }
 }
 
-safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo() : buffer(), bindCount(), pBinds(nullptr) {}
+safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo() : image(), bindCount(), pBinds(nullptr) {}
 
-safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo(const safe_VkSparseBufferMemoryBindInfo& copy_src) {
-    buffer = copy_src.buffer;
+safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& copy_src) {
+    image = copy_src.image;
     bindCount = copy_src.bindCount;
     pBinds = nullptr;
     if (bindCount && copy_src.pBinds) {
-        pBinds = new VkSparseMemoryBind[bindCount];
+        pBinds = new VkSparseImageMemoryBind[bindCount];
         for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = copy_src.pBinds[i];
         }
     }
 }
 
-safe_VkSparseBufferMemoryBindInfo& safe_VkSparseBufferMemoryBindInfo::operator=(const safe_VkSparseBufferMemoryBindInfo& copy_src) {
+safe_VkSparseImageMemoryBindInfo& safe_VkSparseImageMemoryBindInfo::operator=(const safe_VkSparseImageMemoryBindInfo& copy_src) {
     if (&copy_src == this) return *this;
 
     if (pBinds) delete[] pBinds;
 
-    buffer = copy_src.buffer;
+    image = copy_src.image;
     bindCount = copy_src.bindCount;
     pBinds = nullptr;
     if (bindCount && copy_src.pBinds) {
-        pBinds = new VkSparseMemoryBind[bindCount];
+        pBinds = new VkSparseImageMemoryBind[bindCount];
         for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = copy_src.pBinds[i];
         }
@@ -1227,40 +1006,40 @@ safe_VkSparseBufferMemoryBindInfo& safe_VkSparseBufferMemoryBindInfo::operator=(
     return *this;
 }
 
-safe_VkSparseBufferMemoryBindInfo::~safe_VkSparseBufferMemoryBindInfo() {
+safe_VkSparseImageMemoryBindInfo::~safe_VkSparseImageMemoryBindInfo() {
     if (pBinds) delete[] pBinds;
 }
 
-void safe_VkSparseBufferMemoryBindInfo::initialize(const VkSparseBufferMemoryBindInfo* in_struct,
-                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkSparseImageMemoryBindInfo::initialize(const VkSparseImageMemoryBindInfo* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
     if (pBinds) delete[] pBinds;
-    buffer = in_struct->buffer;
+    image = in_struct->image;
     bindCount = in_struct->bindCount;
     pBinds = nullptr;
     if (bindCount && in_struct->pBinds) {
-        pBinds = new VkSparseMemoryBind[bindCount];
+        pBinds = new VkSparseImageMemoryBind[bindCount];
         for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = in_struct->pBinds[i];
         }
     }
 }
 
-void safe_VkSparseBufferMemoryBindInfo::initialize(const safe_VkSparseBufferMemoryBindInfo* copy_src,
-                                                   [[maybe_unused]] PNextCopyState* copy_state) {
-    buffer = copy_src->buffer;
+void safe_VkSparseImageMemoryBindInfo::initialize(const safe_VkSparseImageMemoryBindInfo* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    image = copy_src->image;
     bindCount = copy_src->bindCount;
     pBinds = nullptr;
     if (bindCount && copy_src->pBinds) {
-        pBinds = new VkSparseMemoryBind[bindCount];
+        pBinds = new VkSparseImageMemoryBind[bindCount];
         for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = copy_src->pBinds[i];
         }
     }
 }
 
-safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo* in_struct,
-                                                                               [[maybe_unused]] PNextCopyState* copy_state)
-    : image(in_struct->image), bindCount(in_struct->bindCount), pBinds(nullptr) {
+safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state)
+    : buffer(in_struct->buffer), bindCount(in_struct->bindCount), pBinds(nullptr) {
     if (bindCount && in_struct->pBinds) {
         pBinds = new VkSparseMemoryBind[bindCount];
         for (uint32_t i = 0; i < bindCount; ++i) {
@@ -1269,11 +1048,10 @@ safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo(c
     }
 }
 
-safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo() : image(), bindCount(), pBinds(nullptr) {}
+safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo() : buffer(), bindCount(), pBinds(nullptr) {}
 
-safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo(
-    const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src) {
-    image = copy_src.image;
+safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo(const safe_VkSparseBufferMemoryBindInfo& copy_src) {
+    buffer = copy_src.buffer;
     bindCount = copy_src.bindCount;
     pBinds = nullptr;
     if (bindCount && copy_src.pBinds) {
@@ -1284,13 +1062,12 @@ safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo(
     }
 }
 
-safe_VkSparseImageOpaqueMemoryBindInfo& safe_VkSparseImageOpaqueMemoryBindInfo::operator=(
-    const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src) {
+safe_VkSparseBufferMemoryBindInfo& safe_VkSparseBufferMemoryBindInfo::operator=(const safe_VkSparseBufferMemoryBindInfo& copy_src) {
     if (&copy_src == this) return *this;
 
     if (pBinds) delete[] pBinds;
 
-    image = copy_src.image;
+    buffer = copy_src.buffer;
     bindCount = copy_src.bindCount;
     pBinds = nullptr;
     if (bindCount && copy_src.pBinds) {
@@ -1303,14 +1080,14 @@ safe_VkSparseImageOpaqueMemoryBindInfo& safe_VkSparseImageOpaqueMemoryBindInfo::
     return *this;
 }
 
-safe_VkSparseImageOpaqueMemoryBindInfo::~safe_VkSparseImageOpaqueMemoryBindInfo() {
+safe_VkSparseBufferMemoryBindInfo::~safe_VkSparseBufferMemoryBindInfo() {
     if (pBinds) delete[] pBinds;
 }
 
-void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const VkSparseImageOpaqueMemoryBindInfo* in_struct,
-                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkSparseBufferMemoryBindInfo::initialize(const VkSparseBufferMemoryBindInfo* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
     if (pBinds) delete[] pBinds;
-    image = in_struct->image;
+    buffer = in_struct->buffer;
     bindCount = in_struct->bindCount;
     pBinds = nullptr;
     if (bindCount && in_struct->pBinds) {
@@ -1321,9 +1098,9 @@ void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const VkSparseImageOpaqu
     }
 }
 
-void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const safe_VkSparseImageOpaqueMemoryBindInfo* copy_src,
-                                                        [[maybe_unused]] PNextCopyState* copy_state) {
-    image = copy_src->image;
+void safe_VkSparseBufferMemoryBindInfo::initialize(const safe_VkSparseBufferMemoryBindInfo* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    buffer = copy_src->buffer;
     bindCount = copy_src->bindCount;
     pBinds = nullptr;
     if (bindCount && copy_src->pBinds) {
@@ -1334,32 +1111,34 @@ void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const safe_VkSparseImage
     }
 }
 
-safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* in_struct,
-                                                                   [[maybe_unused]] PNextCopyState* copy_state)
+safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state)
     : image(in_struct->image), bindCount(in_struct->bindCount), pBinds(nullptr) {
     if (bindCount && in_struct->pBinds) {
-        pBinds = new VkSparseImageMemoryBind[bindCount];
+        pBinds = new VkSparseMemoryBind[bindCount];
         for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = in_struct->pBinds[i];
         }
     }
 }
 
-safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo() : image(), bindCount(), pBinds(nullptr) {}
+safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo() : image(), bindCount(), pBinds(nullptr) {}
 
-safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& copy_src) {
+safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo(
+    const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src) {
     image = copy_src.image;
     bindCount = copy_src.bindCount;
     pBinds = nullptr;
     if (bindCount && copy_src.pBinds) {
-        pBinds = new VkSparseImageMemoryBind[bindCount];
+        pBinds = new VkSparseMemoryBind[bindCount];
         for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = copy_src.pBinds[i];
         }
     }
 }
 
-safe_VkSparseImageMemoryBindInfo& safe_VkSparseImageMemoryBindInfo::operator=(const safe_VkSparseImageMemoryBindInfo& copy_src) {
+safe_VkSparseImageOpaqueMemoryBindInfo& safe_VkSparseImageOpaqueMemoryBindInfo::operator=(
+    const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src) {
     if (&copy_src == this) return *this;
 
     if (pBinds) delete[] pBinds;
@@ -1368,7 +1147,7 @@ safe_VkSparseImageMemoryBindInfo& safe_VkSparseImageMemoryBindInfo::operator=(co
     bindCount = copy_src.bindCount;
     pBinds = nullptr;
     if (bindCount && copy_src.pBinds) {
-        pBinds = new VkSparseImageMemoryBind[bindCount];
+        pBinds = new VkSparseMemoryBind[bindCount];
         for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = copy_src.pBinds[i];
         }
@@ -1377,31 +1156,31 @@ safe_VkSparseImageMemoryBindInfo& safe_VkSparseImageMemoryBindInfo::operator=(co
     return *this;
 }
 
-safe_VkSparseImageMemoryBindInfo::~safe_VkSparseImageMemoryBindInfo() {
+safe_VkSparseImageOpaqueMemoryBindInfo::~safe_VkSparseImageOpaqueMemoryBindInfo() {
     if (pBinds) delete[] pBinds;
 }
 
-void safe_VkSparseImageMemoryBindInfo::initialize(const VkSparseImageMemoryBindInfo* in_struct,
-                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const VkSparseImageOpaqueMemoryBindInfo* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
     if (pBinds) delete[] pBinds;
     image = in_struct->image;
     bindCount = in_struct->bindCount;
     pBinds = nullptr;
     if (bindCount && in_struct->pBinds) {
-        pBinds = new VkSparseImageMemoryBind[bindCount];
+        pBinds = new VkSparseMemoryBind[bindCount];
         for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = in_struct->pBinds[i];
         }
     }
 }
 
-void safe_VkSparseImageMemoryBindInfo::initialize(const safe_VkSparseImageMemoryBindInfo* copy_src,
-                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const safe_VkSparseImageOpaqueMemoryBindInfo* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
     image = copy_src->image;
     bindCount = copy_src->bindCount;
     pBinds = nullptr;
     if (bindCount && copy_src->pBinds) {
-        pBinds = new VkSparseImageMemoryBind[bindCount];
+        pBinds = new VkSparseMemoryBind[bindCount];
         for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = copy_src->pBinds[i];
         }
@@ -2433,144 +2212,365 @@ void safe_VkCommandBufferBeginInfo::initialize(const safe_VkCommandBufferBeginIn
     if (copy_src->pInheritanceInfo) pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*copy_src->pInheritanceInfo);
 }
 
-safe_VkEventCreateInfo::safe_VkEventCreateInfo(const VkEventCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
-                                               bool copy_pnext)
-    : sType(in_struct->sType), flags(in_struct->flags) {
+safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      srcAccessMask(in_struct->srcAccessMask),
+      dstAccessMask(in_struct->dstAccessMask),
+      srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex),
+      dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex),
+      buffer(in_struct->buffer),
+      offset(in_struct->offset),
+      size(in_struct->size) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
 }
 
-safe_VkEventCreateInfo::safe_VkEventCreateInfo() : sType(VK_STRUCTURE_TYPE_EVENT_CREATE_INFO), pNext(nullptr), flags() {}
+safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER),
+      pNext(nullptr),
+      srcAccessMask(),
+      dstAccessMask(),
+      srcQueueFamilyIndex(),
+      dstQueueFamilyIndex(),
+      buffer(),
+      offset(),
+      size() {}
 
-safe_VkEventCreateInfo::safe_VkEventCreateInfo(const safe_VkEventCreateInfo& copy_src) {
+safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& copy_src) {
     sType = copy_src.sType;
-    flags = copy_src.flags;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
+    buffer = copy_src.buffer;
+    offset = copy_src.offset;
+    size = copy_src.size;
     pNext = SafePnextCopy(copy_src.pNext);
 }
 
-safe_VkEventCreateInfo& safe_VkEventCreateInfo::operator=(const safe_VkEventCreateInfo& copy_src) {
+safe_VkBufferMemoryBarrier& safe_VkBufferMemoryBarrier::operator=(const safe_VkBufferMemoryBarrier& copy_src) {
     if (&copy_src == this) return *this;
 
     FreePnextChain(pNext);
 
     sType = copy_src.sType;
-    flags = copy_src.flags;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
+    buffer = copy_src.buffer;
+    offset = copy_src.offset;
+    size = copy_src.size;
     pNext = SafePnextCopy(copy_src.pNext);
 
     return *this;
 }
 
-safe_VkEventCreateInfo::~safe_VkEventCreateInfo() { FreePnextChain(pNext); }
+safe_VkBufferMemoryBarrier::~safe_VkBufferMemoryBarrier() { FreePnextChain(pNext); }
 
-void safe_VkEventCreateInfo::initialize(const VkEventCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkBufferMemoryBarrier::initialize(const VkBufferMemoryBarrier* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
     FreePnextChain(pNext);
     sType = in_struct->sType;
-    flags = in_struct->flags;
+    srcAccessMask = in_struct->srcAccessMask;
+    dstAccessMask = in_struct->dstAccessMask;
+    srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex;
+    dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex;
+    buffer = in_struct->buffer;
+    offset = in_struct->offset;
+    size = in_struct->size;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
 }
 
-void safe_VkEventCreateInfo::initialize(const safe_VkEventCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkBufferMemoryBarrier::initialize(const safe_VkBufferMemoryBarrier* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
-    flags = copy_src->flags;
+    srcAccessMask = copy_src->srcAccessMask;
+    dstAccessMask = copy_src->dstAccessMask;
+    srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex;
+    buffer = copy_src->buffer;
+    offset = copy_src->offset;
+    size = copy_src->size;
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* in_struct,
-                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
-      flags(in_struct->flags),
-      buffer(in_struct->buffer),
-      format(in_struct->format),
-      offset(in_struct->offset),
-      range(in_struct->range) {
+      srcAccessMask(in_struct->srcAccessMask),
+      dstAccessMask(in_struct->dstAccessMask),
+      oldLayout(in_struct->oldLayout),
+      newLayout(in_struct->newLayout),
+      srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex),
+      dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex),
+      image(in_struct->image),
+      subresourceRange(in_struct->subresourceRange) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
 }
 
-safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo()
-    : sType(VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO), pNext(nullptr), flags(), buffer(), format(), offset(), range() {}
+safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER),
+      pNext(nullptr),
+      srcAccessMask(),
+      dstAccessMask(),
+      oldLayout(),
+      newLayout(),
+      srcQueueFamilyIndex(),
+      dstQueueFamilyIndex(),
+      image(),
+      subresourceRange() {}
 
-safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo(const safe_VkBufferViewCreateInfo& copy_src) {
+safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& copy_src) {
     sType = copy_src.sType;
-    flags = copy_src.flags;
-    buffer = copy_src.buffer;
-    format = copy_src.format;
-    offset = copy_src.offset;
-    range = copy_src.range;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    oldLayout = copy_src.oldLayout;
+    newLayout = copy_src.newLayout;
+    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
+    image = copy_src.image;
+    subresourceRange = copy_src.subresourceRange;
     pNext = SafePnextCopy(copy_src.pNext);
 }
 
-safe_VkBufferViewCreateInfo& safe_VkBufferViewCreateInfo::operator=(const safe_VkBufferViewCreateInfo& copy_src) {
+safe_VkImageMemoryBarrier& safe_VkImageMemoryBarrier::operator=(const safe_VkImageMemoryBarrier& copy_src) {
     if (&copy_src == this) return *this;
 
     FreePnextChain(pNext);
 
     sType = copy_src.sType;
-    flags = copy_src.flags;
-    buffer = copy_src.buffer;
-    format = copy_src.format;
-    offset = copy_src.offset;
-    range = copy_src.range;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    oldLayout = copy_src.oldLayout;
+    newLayout = copy_src.newLayout;
+    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
+    image = copy_src.image;
+    subresourceRange = copy_src.subresourceRange;
     pNext = SafePnextCopy(copy_src.pNext);
 
     return *this;
 }
 
-safe_VkBufferViewCreateInfo::~safe_VkBufferViewCreateInfo() { FreePnextChain(pNext); }
+safe_VkImageMemoryBarrier::~safe_VkImageMemoryBarrier() { FreePnextChain(pNext); }
 
-void safe_VkBufferViewCreateInfo::initialize(const VkBufferViewCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkImageMemoryBarrier::initialize(const VkImageMemoryBarrier* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
     FreePnextChain(pNext);
     sType = in_struct->sType;
-    flags = in_struct->flags;
-    buffer = in_struct->buffer;
-    format = in_struct->format;
-    offset = in_struct->offset;
-    range = in_struct->range;
+    srcAccessMask = in_struct->srcAccessMask;
+    dstAccessMask = in_struct->dstAccessMask;
+    oldLayout = in_struct->oldLayout;
+    newLayout = in_struct->newLayout;
+    srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex;
+    dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex;
+    image = in_struct->image;
+    subresourceRange = in_struct->subresourceRange;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
 }
 
-void safe_VkBufferViewCreateInfo::initialize(const safe_VkBufferViewCreateInfo* copy_src,
-                                             [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkImageMemoryBarrier::initialize(const safe_VkImageMemoryBarrier* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
-    flags = copy_src->flags;
-    buffer = copy_src->buffer;
-    format = copy_src->format;
-    offset = copy_src->offset;
-    range = copy_src->range;
+    srcAccessMask = copy_src->srcAccessMask;
+    dstAccessMask = copy_src->dstAccessMask;
+    oldLayout = copy_src->oldLayout;
+    newLayout = copy_src->newLayout;
+    srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex;
+    image = copy_src->image;
+    subresourceRange = copy_src->subresourceRange;
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo* in_struct,
-                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), flags(in_struct->flags), codeSize(in_struct->codeSize), pCode(nullptr) {
+safe_VkMemoryBarrier::safe_VkMemoryBarrier(const VkMemoryBarrier* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                           bool copy_pnext)
+    : sType(in_struct->sType), srcAccessMask(in_struct->srcAccessMask), dstAccessMask(in_struct->dstAccessMask) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
-    if (in_struct->pCode) {
-        pCode = reinterpret_cast<uint32_t*>(new uint8_t[codeSize]);
-        memcpy((void*)pCode, (void*)in_struct->pCode, codeSize);
-    }
 }
 
-safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo()
-    : sType(VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO), pNext(nullptr), flags(), codeSize(), pCode(nullptr) {}
+safe_VkMemoryBarrier::safe_VkMemoryBarrier()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_BARRIER), pNext(nullptr), srcAccessMask(), dstAccessMask() {}
 
-safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo(const safe_VkShaderModuleCreateInfo& copy_src) {
+safe_VkMemoryBarrier::safe_VkMemoryBarrier(const safe_VkMemoryBarrier& copy_src) {
     sType = copy_src.sType;
-    flags = copy_src.flags;
-    codeSize = copy_src.codeSize;
-    pCode = nullptr;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstAccessMask = copy_src.dstAccessMask;
     pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pCode) {
-        pCode = reinterpret_cast<uint32_t*>(new uint8_t[codeSize]);
-        memcpy((void*)pCode, (void*)copy_src.pCode, codeSize);
-    }
 }
 
-safe_VkShaderModuleCreateInfo& safe_VkShaderModuleCreateInfo::operator=(const safe_VkShaderModuleCreateInfo& copy_src) {
+safe_VkMemoryBarrier& safe_VkMemoryBarrier::operator=(const safe_VkMemoryBarrier& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryBarrier::~safe_VkMemoryBarrier() { FreePnextChain(pNext); }
+
+void safe_VkMemoryBarrier::initialize(const VkMemoryBarrier* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcAccessMask = in_struct->srcAccessMask;
+    dstAccessMask = in_struct->dstAccessMask;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryBarrier::initialize(const safe_VkMemoryBarrier* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcAccessMask = copy_src->srcAccessMask;
+    dstAccessMask = copy_src->dstAccessMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkEventCreateInfo::safe_VkEventCreateInfo(const VkEventCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                               bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkEventCreateInfo::safe_VkEventCreateInfo() : sType(VK_STRUCTURE_TYPE_EVENT_CREATE_INFO), pNext(nullptr), flags() {}
+
+safe_VkEventCreateInfo::safe_VkEventCreateInfo(const safe_VkEventCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkEventCreateInfo& safe_VkEventCreateInfo::operator=(const safe_VkEventCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkEventCreateInfo::~safe_VkEventCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkEventCreateInfo::initialize(const VkEventCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkEventCreateInfo::initialize(const safe_VkEventCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      buffer(in_struct->buffer),
+      format(in_struct->format),
+      offset(in_struct->offset),
+      range(in_struct->range) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO), pNext(nullptr), flags(), buffer(), format(), offset(), range() {}
+
+safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo(const safe_VkBufferViewCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    buffer = copy_src.buffer;
+    format = copy_src.format;
+    offset = copy_src.offset;
+    range = copy_src.range;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferViewCreateInfo& safe_VkBufferViewCreateInfo::operator=(const safe_VkBufferViewCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    buffer = copy_src.buffer;
+    format = copy_src.format;
+    offset = copy_src.offset;
+    range = copy_src.range;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferViewCreateInfo::~safe_VkBufferViewCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkBufferViewCreateInfo::initialize(const VkBufferViewCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    buffer = in_struct->buffer;
+    format = in_struct->format;
+    offset = in_struct->offset;
+    range = in_struct->range;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferViewCreateInfo::initialize(const safe_VkBufferViewCreateInfo* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    buffer = copy_src->buffer;
+    format = copy_src->format;
+    offset = copy_src->offset;
+    range = copy_src->range;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), codeSize(in_struct->codeSize), pCode(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pCode) {
+        pCode = reinterpret_cast<uint32_t*>(new uint8_t[codeSize]);
+        memcpy((void*)pCode, (void*)in_struct->pCode, codeSize);
+    }
+}
+
+safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO), pNext(nullptr), flags(), codeSize(), pCode(nullptr) {}
+
+safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo(const safe_VkShaderModuleCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    codeSize = copy_src.codeSize;
+    pCode = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pCode) {
+        pCode = reinterpret_cast<uint32_t*>(new uint8_t[codeSize]);
+        memcpy((void*)pCode, (void*)copy_src.pCode, codeSize);
+    }
+}
+
+safe_VkShaderModuleCreateInfo& safe_VkShaderModuleCreateInfo::operator=(const safe_VkShaderModuleCreateInfo& copy_src) {
     if (&copy_src == this) return *this;
 
     if (pCode) delete[] reinterpret_cast<const uint8_t*>(pCode);
@@ -3992,371 +3992,390 @@ void safe_VkWriteDescriptorSet::initialize(const safe_VkWriteDescriptorSet* copy
     }
 }
 
-safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo(
-    const VkPipelineVertexInputStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo(
+    const VkPipelineColorBlendStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
       flags(in_struct->flags),
-      vertexBindingDescriptionCount(in_struct->vertexBindingDescriptionCount),
-      pVertexBindingDescriptions(nullptr),
-      vertexAttributeDescriptionCount(in_struct->vertexAttributeDescriptionCount),
-      pVertexAttributeDescriptions(nullptr) {
+      logicOpEnable(in_struct->logicOpEnable),
+      logicOp(in_struct->logicOp),
+      attachmentCount(in_struct->attachmentCount),
+      pAttachments(nullptr) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
-    if (in_struct->pVertexBindingDescriptions) {
-        pVertexBindingDescriptions = new VkVertexInputBindingDescription[in_struct->vertexBindingDescriptionCount];
-        memcpy((void*)pVertexBindingDescriptions, (void*)in_struct->pVertexBindingDescriptions,
-               sizeof(VkVertexInputBindingDescription) * in_struct->vertexBindingDescriptionCount);
+    if (in_struct->pAttachments) {
+        pAttachments = new VkPipelineColorBlendAttachmentState[in_struct->attachmentCount];
+        memcpy((void*)pAttachments, (void*)in_struct->pAttachments,
+               sizeof(VkPipelineColorBlendAttachmentState) * in_struct->attachmentCount);
     }
 
-    if (in_struct->pVertexAttributeDescriptions) {
-        pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[in_struct->vertexAttributeDescriptionCount];
-        memcpy((void*)pVertexAttributeDescriptions, (void*)in_struct->pVertexAttributeDescriptions,
-               sizeof(VkVertexInputAttributeDescription) * in_struct->vertexAttributeDescriptionCount);
+    for (uint32_t i = 0; i < 4; ++i) {
+        blendConstants[i] = in_struct->blendConstants[i];
     }
 }
 
-safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo()
-    : sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO),
+safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO),
       pNext(nullptr),
       flags(),
-      vertexBindingDescriptionCount(),
-      pVertexBindingDescriptions(nullptr),
-      vertexAttributeDescriptionCount(),
-      pVertexAttributeDescriptions(nullptr) {}
+      logicOpEnable(),
+      logicOp(),
+      attachmentCount(),
+      pAttachments(nullptr) {}
 
-safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo(
-    const safe_VkPipelineVertexInputStateCreateInfo& copy_src) {
+safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo(
+    const safe_VkPipelineColorBlendStateCreateInfo& copy_src) {
     sType = copy_src.sType;
     flags = copy_src.flags;
-    vertexBindingDescriptionCount = copy_src.vertexBindingDescriptionCount;
-    pVertexBindingDescriptions = nullptr;
-    vertexAttributeDescriptionCount = copy_src.vertexAttributeDescriptionCount;
-    pVertexAttributeDescriptions = nullptr;
+    logicOpEnable = copy_src.logicOpEnable;
+    logicOp = copy_src.logicOp;
+    attachmentCount = copy_src.attachmentCount;
+    pAttachments = nullptr;
     pNext = SafePnextCopy(copy_src.pNext);
 
-    if (copy_src.pVertexBindingDescriptions) {
-        pVertexBindingDescriptions = new VkVertexInputBindingDescription[copy_src.vertexBindingDescriptionCount];
-        memcpy((void*)pVertexBindingDescriptions, (void*)copy_src.pVertexBindingDescriptions,
-               sizeof(VkVertexInputBindingDescription) * copy_src.vertexBindingDescriptionCount);
+    if (copy_src.pAttachments) {
+        pAttachments = new VkPipelineColorBlendAttachmentState[copy_src.attachmentCount];
+        memcpy((void*)pAttachments, (void*)copy_src.pAttachments,
+               sizeof(VkPipelineColorBlendAttachmentState) * copy_src.attachmentCount);
     }
 
-    if (copy_src.pVertexAttributeDescriptions) {
-        pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[copy_src.vertexAttributeDescriptionCount];
-        memcpy((void*)pVertexAttributeDescriptions, (void*)copy_src.pVertexAttributeDescriptions,
-               sizeof(VkVertexInputAttributeDescription) * copy_src.vertexAttributeDescriptionCount);
+    for (uint32_t i = 0; i < 4; ++i) {
+        blendConstants[i] = copy_src.blendConstants[i];
     }
 }
 
-safe_VkPipelineVertexInputStateCreateInfo& safe_VkPipelineVertexInputStateCreateInfo::operator=(
-    const safe_VkPipelineVertexInputStateCreateInfo& copy_src) {
+safe_VkPipelineColorBlendStateCreateInfo& safe_VkPipelineColorBlendStateCreateInfo::operator=(
+    const safe_VkPipelineColorBlendStateCreateInfo& copy_src) {
     if (&copy_src == this) return *this;
 
-    if (pVertexBindingDescriptions) delete[] pVertexBindingDescriptions;
-    if (pVertexAttributeDescriptions) delete[] pVertexAttributeDescriptions;
+    if (pAttachments) delete[] pAttachments;
     FreePnextChain(pNext);
 
     sType = copy_src.sType;
     flags = copy_src.flags;
-    vertexBindingDescriptionCount = copy_src.vertexBindingDescriptionCount;
-    pVertexBindingDescriptions = nullptr;
-    vertexAttributeDescriptionCount = copy_src.vertexAttributeDescriptionCount;
-    pVertexAttributeDescriptions = nullptr;
+    logicOpEnable = copy_src.logicOpEnable;
+    logicOp = copy_src.logicOp;
+    attachmentCount = copy_src.attachmentCount;
+    pAttachments = nullptr;
     pNext = SafePnextCopy(copy_src.pNext);
 
-    if (copy_src.pVertexBindingDescriptions) {
-        pVertexBindingDescriptions = new VkVertexInputBindingDescription[copy_src.vertexBindingDescriptionCount];
-        memcpy((void*)pVertexBindingDescriptions, (void*)copy_src.pVertexBindingDescriptions,
-               sizeof(VkVertexInputBindingDescription) * copy_src.vertexBindingDescriptionCount);
+    if (copy_src.pAttachments) {
+        pAttachments = new VkPipelineColorBlendAttachmentState[copy_src.attachmentCount];
+        memcpy((void*)pAttachments, (void*)copy_src.pAttachments,
+               sizeof(VkPipelineColorBlendAttachmentState) * copy_src.attachmentCount);
     }
 
-    if (copy_src.pVertexAttributeDescriptions) {
-        pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[copy_src.vertexAttributeDescriptionCount];
-        memcpy((void*)pVertexAttributeDescriptions, (void*)copy_src.pVertexAttributeDescriptions,
-               sizeof(VkVertexInputAttributeDescription) * copy_src.vertexAttributeDescriptionCount);
+    for (uint32_t i = 0; i < 4; ++i) {
+        blendConstants[i] = copy_src.blendConstants[i];
     }
 
     return *this;
 }
 
-safe_VkPipelineVertexInputStateCreateInfo::~safe_VkPipelineVertexInputStateCreateInfo() {
-    if (pVertexBindingDescriptions) delete[] pVertexBindingDescriptions;
-    if (pVertexAttributeDescriptions) delete[] pVertexAttributeDescriptions;
+safe_VkPipelineColorBlendStateCreateInfo::~safe_VkPipelineColorBlendStateCreateInfo() {
+    if (pAttachments) delete[] pAttachments;
     FreePnextChain(pNext);
 }
 
-void safe_VkPipelineVertexInputStateCreateInfo::initialize(const VkPipelineVertexInputStateCreateInfo* in_struct,
-                                                           [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pVertexBindingDescriptions) delete[] pVertexBindingDescriptions;
-    if (pVertexAttributeDescriptions) delete[] pVertexAttributeDescriptions;
+void safe_VkPipelineColorBlendStateCreateInfo::initialize(const VkPipelineColorBlendStateCreateInfo* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAttachments) delete[] pAttachments;
     FreePnextChain(pNext);
     sType = in_struct->sType;
     flags = in_struct->flags;
-    vertexBindingDescriptionCount = in_struct->vertexBindingDescriptionCount;
-    pVertexBindingDescriptions = nullptr;
-    vertexAttributeDescriptionCount = in_struct->vertexAttributeDescriptionCount;
-    pVertexAttributeDescriptions = nullptr;
+    logicOpEnable = in_struct->logicOpEnable;
+    logicOp = in_struct->logicOp;
+    attachmentCount = in_struct->attachmentCount;
+    pAttachments = nullptr;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
 
-    if (in_struct->pVertexBindingDescriptions) {
-        pVertexBindingDescriptions = new VkVertexInputBindingDescription[in_struct->vertexBindingDescriptionCount];
-        memcpy((void*)pVertexBindingDescriptions, (void*)in_struct->pVertexBindingDescriptions,
-               sizeof(VkVertexInputBindingDescription) * in_struct->vertexBindingDescriptionCount);
+    if (in_struct->pAttachments) {
+        pAttachments = new VkPipelineColorBlendAttachmentState[in_struct->attachmentCount];
+        memcpy((void*)pAttachments, (void*)in_struct->pAttachments,
+               sizeof(VkPipelineColorBlendAttachmentState) * in_struct->attachmentCount);
     }
 
-    if (in_struct->pVertexAttributeDescriptions) {
-        pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[in_struct->vertexAttributeDescriptionCount];
-        memcpy((void*)pVertexAttributeDescriptions, (void*)in_struct->pVertexAttributeDescriptions,
-               sizeof(VkVertexInputAttributeDescription) * in_struct->vertexAttributeDescriptionCount);
+    for (uint32_t i = 0; i < 4; ++i) {
+        blendConstants[i] = in_struct->blendConstants[i];
     }
 }
 
-void safe_VkPipelineVertexInputStateCreateInfo::initialize(const safe_VkPipelineVertexInputStateCreateInfo* copy_src,
-                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkPipelineColorBlendStateCreateInfo::initialize(const safe_VkPipelineColorBlendStateCreateInfo* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
     flags = copy_src->flags;
-    vertexBindingDescriptionCount = copy_src->vertexBindingDescriptionCount;
-    pVertexBindingDescriptions = nullptr;
-    vertexAttributeDescriptionCount = copy_src->vertexAttributeDescriptionCount;
-    pVertexAttributeDescriptions = nullptr;
+    logicOpEnable = copy_src->logicOpEnable;
+    logicOp = copy_src->logicOp;
+    attachmentCount = copy_src->attachmentCount;
+    pAttachments = nullptr;
     pNext = SafePnextCopy(copy_src->pNext);
 
-    if (copy_src->pVertexBindingDescriptions) {
-        pVertexBindingDescriptions = new VkVertexInputBindingDescription[copy_src->vertexBindingDescriptionCount];
-        memcpy((void*)pVertexBindingDescriptions, (void*)copy_src->pVertexBindingDescriptions,
-               sizeof(VkVertexInputBindingDescription) * copy_src->vertexBindingDescriptionCount);
+    if (copy_src->pAttachments) {
+        pAttachments = new VkPipelineColorBlendAttachmentState[copy_src->attachmentCount];
+        memcpy((void*)pAttachments, (void*)copy_src->pAttachments,
+               sizeof(VkPipelineColorBlendAttachmentState) * copy_src->attachmentCount);
     }
 
-    if (copy_src->pVertexAttributeDescriptions) {
-        pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[copy_src->vertexAttributeDescriptionCount];
-        memcpy((void*)pVertexAttributeDescriptions, (void*)copy_src->pVertexAttributeDescriptions,
-               sizeof(VkVertexInputAttributeDescription) * copy_src->vertexAttributeDescriptionCount);
+    for (uint32_t i = 0; i < 4; ++i) {
+        blendConstants[i] = copy_src->blendConstants[i];
     }
 }
 
-safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo(
-    const VkPipelineInputAssemblyStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo(
+    const VkPipelineDepthStencilStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
       flags(in_struct->flags),
-      topology(in_struct->topology),
-      primitiveRestartEnable(in_struct->primitiveRestartEnable) {
+      depthTestEnable(in_struct->depthTestEnable),
+      depthWriteEnable(in_struct->depthWriteEnable),
+      depthCompareOp(in_struct->depthCompareOp),
+      depthBoundsTestEnable(in_struct->depthBoundsTestEnable),
+      stencilTestEnable(in_struct->stencilTestEnable),
+      front(in_struct->front),
+      back(in_struct->back),
+      minDepthBounds(in_struct->minDepthBounds),
+      maxDepthBounds(in_struct->maxDepthBounds) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
 }
 
-safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo()
-    : sType(VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO),
+safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO),
       pNext(nullptr),
       flags(),
-      topology(),
-      primitiveRestartEnable() {}
+      depthTestEnable(),
+      depthWriteEnable(),
+      depthCompareOp(),
+      depthBoundsTestEnable(),
+      stencilTestEnable(),
+      front(),
+      back(),
+      minDepthBounds(),
+      maxDepthBounds() {}
 
-safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo(
-    const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src) {
+safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo(
+    const safe_VkPipelineDepthStencilStateCreateInfo& copy_src) {
     sType = copy_src.sType;
     flags = copy_src.flags;
-    topology = copy_src.topology;
-    primitiveRestartEnable = copy_src.primitiveRestartEnable;
+    depthTestEnable = copy_src.depthTestEnable;
+    depthWriteEnable = copy_src.depthWriteEnable;
+    depthCompareOp = copy_src.depthCompareOp;
+    depthBoundsTestEnable = copy_src.depthBoundsTestEnable;
+    stencilTestEnable = copy_src.stencilTestEnable;
+    front = copy_src.front;
+    back = copy_src.back;
+    minDepthBounds = copy_src.minDepthBounds;
+    maxDepthBounds = copy_src.maxDepthBounds;
     pNext = SafePnextCopy(copy_src.pNext);
 }
 
-safe_VkPipelineInputAssemblyStateCreateInfo& safe_VkPipelineInputAssemblyStateCreateInfo::operator=(
-    const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src) {
+safe_VkPipelineDepthStencilStateCreateInfo& safe_VkPipelineDepthStencilStateCreateInfo::operator=(
+    const safe_VkPipelineDepthStencilStateCreateInfo& copy_src) {
     if (&copy_src == this) return *this;
 
     FreePnextChain(pNext);
 
     sType = copy_src.sType;
     flags = copy_src.flags;
-    topology = copy_src.topology;
-    primitiveRestartEnable = copy_src.primitiveRestartEnable;
+    depthTestEnable = copy_src.depthTestEnable;
+    depthWriteEnable = copy_src.depthWriteEnable;
+    depthCompareOp = copy_src.depthCompareOp;
+    depthBoundsTestEnable = copy_src.depthBoundsTestEnable;
+    stencilTestEnable = copy_src.stencilTestEnable;
+    front = copy_src.front;
+    back = copy_src.back;
+    minDepthBounds = copy_src.minDepthBounds;
+    maxDepthBounds = copy_src.maxDepthBounds;
     pNext = SafePnextCopy(copy_src.pNext);
 
     return *this;
 }
 
-safe_VkPipelineInputAssemblyStateCreateInfo::~safe_VkPipelineInputAssemblyStateCreateInfo() { FreePnextChain(pNext); }
+safe_VkPipelineDepthStencilStateCreateInfo::~safe_VkPipelineDepthStencilStateCreateInfo() { FreePnextChain(pNext); }
 
-void safe_VkPipelineInputAssemblyStateCreateInfo::initialize(const VkPipelineInputAssemblyStateCreateInfo* in_struct,
-                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
     FreePnextChain(pNext);
     sType = in_struct->sType;
     flags = in_struct->flags;
-    topology = in_struct->topology;
-    primitiveRestartEnable = in_struct->primitiveRestartEnable;
+    depthTestEnable = in_struct->depthTestEnable;
+    depthWriteEnable = in_struct->depthWriteEnable;
+    depthCompareOp = in_struct->depthCompareOp;
+    depthBoundsTestEnable = in_struct->depthBoundsTestEnable;
+    stencilTestEnable = in_struct->stencilTestEnable;
+    front = in_struct->front;
+    back = in_struct->back;
+    minDepthBounds = in_struct->minDepthBounds;
+    maxDepthBounds = in_struct->maxDepthBounds;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
 }
 
-void safe_VkPipelineInputAssemblyStateCreateInfo::initialize(const safe_VkPipelineInputAssemblyStateCreateInfo* copy_src,
-                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const safe_VkPipelineDepthStencilStateCreateInfo* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
     flags = copy_src->flags;
-    topology = copy_src->topology;
-    primitiveRestartEnable = copy_src->primitiveRestartEnable;
+    depthTestEnable = copy_src->depthTestEnable;
+    depthWriteEnable = copy_src->depthWriteEnable;
+    depthCompareOp = copy_src->depthCompareOp;
+    depthBoundsTestEnable = copy_src->depthBoundsTestEnable;
+    stencilTestEnable = copy_src->stencilTestEnable;
+    front = copy_src->front;
+    back = copy_src->back;
+    minDepthBounds = copy_src->minDepthBounds;
+    maxDepthBounds = copy_src->maxDepthBounds;
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo(
-    const VkPipelineTessellationStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), flags(in_struct->flags), patchControlPoints(in_struct->patchControlPoints) {
+safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), dynamicStateCount(in_struct->dynamicStateCount), pDynamicStates(nullptr) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
+    if (in_struct->pDynamicStates) {
+        pDynamicStates = new VkDynamicState[in_struct->dynamicStateCount];
+        memcpy((void*)pDynamicStates, (void*)in_struct->pDynamicStates, sizeof(VkDynamicState) * in_struct->dynamicStateCount);
+    }
 }
 
-safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo()
-    : sType(VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO), pNext(nullptr), flags(), patchControlPoints() {}
+safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      dynamicStateCount(),
+      pDynamicStates(nullptr) {}
 
-safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo(
-    const safe_VkPipelineTessellationStateCreateInfo& copy_src) {
+safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo(
+    const safe_VkPipelineDynamicStateCreateInfo& copy_src) {
     sType = copy_src.sType;
     flags = copy_src.flags;
-    patchControlPoints = copy_src.patchControlPoints;
+    dynamicStateCount = copy_src.dynamicStateCount;
+    pDynamicStates = nullptr;
     pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDynamicStates) {
+        pDynamicStates = new VkDynamicState[copy_src.dynamicStateCount];
+        memcpy((void*)pDynamicStates, (void*)copy_src.pDynamicStates, sizeof(VkDynamicState) * copy_src.dynamicStateCount);
+    }
 }
 
-safe_VkPipelineTessellationStateCreateInfo& safe_VkPipelineTessellationStateCreateInfo::operator=(
-    const safe_VkPipelineTessellationStateCreateInfo& copy_src) {
+safe_VkPipelineDynamicStateCreateInfo& safe_VkPipelineDynamicStateCreateInfo::operator=(
+    const safe_VkPipelineDynamicStateCreateInfo& copy_src) {
     if (&copy_src == this) return *this;
 
+    if (pDynamicStates) delete[] pDynamicStates;
     FreePnextChain(pNext);
 
     sType = copy_src.sType;
     flags = copy_src.flags;
-    patchControlPoints = copy_src.patchControlPoints;
+    dynamicStateCount = copy_src.dynamicStateCount;
+    pDynamicStates = nullptr;
     pNext = SafePnextCopy(copy_src.pNext);
 
+    if (copy_src.pDynamicStates) {
+        pDynamicStates = new VkDynamicState[copy_src.dynamicStateCount];
+        memcpy((void*)pDynamicStates, (void*)copy_src.pDynamicStates, sizeof(VkDynamicState) * copy_src.dynamicStateCount);
+    }
+
     return *this;
 }
 
-safe_VkPipelineTessellationStateCreateInfo::~safe_VkPipelineTessellationStateCreateInfo() { FreePnextChain(pNext); }
+safe_VkPipelineDynamicStateCreateInfo::~safe_VkPipelineDynamicStateCreateInfo() {
+    if (pDynamicStates) delete[] pDynamicStates;
+    FreePnextChain(pNext);
+}
 
-void safe_VkPipelineTessellationStateCreateInfo::initialize(const VkPipelineTessellationStateCreateInfo* in_struct,
-                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkPipelineDynamicStateCreateInfo::initialize(const VkPipelineDynamicStateCreateInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDynamicStates) delete[] pDynamicStates;
     FreePnextChain(pNext);
     sType = in_struct->sType;
     flags = in_struct->flags;
-    patchControlPoints = in_struct->patchControlPoints;
+    dynamicStateCount = in_struct->dynamicStateCount;
+    pDynamicStates = nullptr;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDynamicStates) {
+        pDynamicStates = new VkDynamicState[in_struct->dynamicStateCount];
+        memcpy((void*)pDynamicStates, (void*)in_struct->pDynamicStates, sizeof(VkDynamicState) * in_struct->dynamicStateCount);
+    }
 }
 
-void safe_VkPipelineTessellationStateCreateInfo::initialize(const safe_VkPipelineTessellationStateCreateInfo* copy_src,
-                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkPipelineDynamicStateCreateInfo::initialize(const safe_VkPipelineDynamicStateCreateInfo* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
     flags = copy_src->flags;
-    patchControlPoints = copy_src->patchControlPoints;
+    dynamicStateCount = copy_src->dynamicStateCount;
+    pDynamicStates = nullptr;
     pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDynamicStates) {
+        pDynamicStates = new VkDynamicState[copy_src->dynamicStateCount];
+        memcpy((void*)pDynamicStates, (void*)copy_src->pDynamicStates, sizeof(VkDynamicState) * copy_src->dynamicStateCount);
+    }
 }
 
-safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo(
-    const VkPipelineRasterizationStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo(
+    const VkPipelineInputAssemblyStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
       flags(in_struct->flags),
-      depthClampEnable(in_struct->depthClampEnable),
-      rasterizerDiscardEnable(in_struct->rasterizerDiscardEnable),
-      polygonMode(in_struct->polygonMode),
-      cullMode(in_struct->cullMode),
-      frontFace(in_struct->frontFace),
-      depthBiasEnable(in_struct->depthBiasEnable),
-      depthBiasConstantFactor(in_struct->depthBiasConstantFactor),
-      depthBiasClamp(in_struct->depthBiasClamp),
-      depthBiasSlopeFactor(in_struct->depthBiasSlopeFactor),
-      lineWidth(in_struct->lineWidth) {
+      topology(in_struct->topology),
+      primitiveRestartEnable(in_struct->primitiveRestartEnable) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
 }
 
-safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo()
-    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO),
+safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO),
       pNext(nullptr),
       flags(),
-      depthClampEnable(),
-      rasterizerDiscardEnable(),
-      polygonMode(),
-      cullMode(),
-      frontFace(),
-      depthBiasEnable(),
-      depthBiasConstantFactor(),
-      depthBiasClamp(),
-      depthBiasSlopeFactor(),
-      lineWidth() {}
+      topology(),
+      primitiveRestartEnable() {}
 
-safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo(
-    const safe_VkPipelineRasterizationStateCreateInfo& copy_src) {
+safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo(
+    const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src) {
     sType = copy_src.sType;
     flags = copy_src.flags;
-    depthClampEnable = copy_src.depthClampEnable;
-    rasterizerDiscardEnable = copy_src.rasterizerDiscardEnable;
-    polygonMode = copy_src.polygonMode;
-    cullMode = copy_src.cullMode;
-    frontFace = copy_src.frontFace;
-    depthBiasEnable = copy_src.depthBiasEnable;
-    depthBiasConstantFactor = copy_src.depthBiasConstantFactor;
-    depthBiasClamp = copy_src.depthBiasClamp;
-    depthBiasSlopeFactor = copy_src.depthBiasSlopeFactor;
-    lineWidth = copy_src.lineWidth;
+    topology = copy_src.topology;
+    primitiveRestartEnable = copy_src.primitiveRestartEnable;
     pNext = SafePnextCopy(copy_src.pNext);
 }
 
-safe_VkPipelineRasterizationStateCreateInfo& safe_VkPipelineRasterizationStateCreateInfo::operator=(
-    const safe_VkPipelineRasterizationStateCreateInfo& copy_src) {
+safe_VkPipelineInputAssemblyStateCreateInfo& safe_VkPipelineInputAssemblyStateCreateInfo::operator=(
+    const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src) {
     if (&copy_src == this) return *this;
 
     FreePnextChain(pNext);
 
     sType = copy_src.sType;
     flags = copy_src.flags;
-    depthClampEnable = copy_src.depthClampEnable;
-    rasterizerDiscardEnable = copy_src.rasterizerDiscardEnable;
-    polygonMode = copy_src.polygonMode;
-    cullMode = copy_src.cullMode;
-    frontFace = copy_src.frontFace;
-    depthBiasEnable = copy_src.depthBiasEnable;
-    depthBiasConstantFactor = copy_src.depthBiasConstantFactor;
-    depthBiasClamp = copy_src.depthBiasClamp;
-    depthBiasSlopeFactor = copy_src.depthBiasSlopeFactor;
-    lineWidth = copy_src.lineWidth;
+    topology = copy_src.topology;
+    primitiveRestartEnable = copy_src.primitiveRestartEnable;
     pNext = SafePnextCopy(copy_src.pNext);
 
     return *this;
 }
 
-safe_VkPipelineRasterizationStateCreateInfo::~safe_VkPipelineRasterizationStateCreateInfo() { FreePnextChain(pNext); }
+safe_VkPipelineInputAssemblyStateCreateInfo::~safe_VkPipelineInputAssemblyStateCreateInfo() { FreePnextChain(pNext); }
 
-void safe_VkPipelineRasterizationStateCreateInfo::initialize(const VkPipelineRasterizationStateCreateInfo* in_struct,
+void safe_VkPipelineInputAssemblyStateCreateInfo::initialize(const VkPipelineInputAssemblyStateCreateInfo* in_struct,
                                                              [[maybe_unused]] PNextCopyState* copy_state) {
     FreePnextChain(pNext);
     sType = in_struct->sType;
     flags = in_struct->flags;
-    depthClampEnable = in_struct->depthClampEnable;
-    rasterizerDiscardEnable = in_struct->rasterizerDiscardEnable;
-    polygonMode = in_struct->polygonMode;
-    cullMode = in_struct->cullMode;
-    frontFace = in_struct->frontFace;
-    depthBiasEnable = in_struct->depthBiasEnable;
-    depthBiasConstantFactor = in_struct->depthBiasConstantFactor;
-    depthBiasClamp = in_struct->depthBiasClamp;
-    depthBiasSlopeFactor = in_struct->depthBiasSlopeFactor;
-    lineWidth = in_struct->lineWidth;
+    topology = in_struct->topology;
+    primitiveRestartEnable = in_struct->primitiveRestartEnable;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
 }
 
-void safe_VkPipelineRasterizationStateCreateInfo::initialize(const safe_VkPipelineRasterizationStateCreateInfo* copy_src,
+void safe_VkPipelineInputAssemblyStateCreateInfo::initialize(const safe_VkPipelineInputAssemblyStateCreateInfo* copy_src,
                                                              [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
     flags = copy_src->flags;
-    depthClampEnable = copy_src->depthClampEnable;
-    rasterizerDiscardEnable = copy_src->rasterizerDiscardEnable;
-    polygonMode = copy_src->polygonMode;
-    cullMode = copy_src->cullMode;
-    frontFace = copy_src->frontFace;
-    depthBiasEnable = copy_src->depthBiasEnable;
-    depthBiasConstantFactor = copy_src->depthBiasConstantFactor;
-    depthBiasClamp = copy_src->depthBiasClamp;
-    depthBiasSlopeFactor = copy_src->depthBiasSlopeFactor;
-    lineWidth = copy_src->lineWidth;
+    topology = copy_src->topology;
+    primitiveRestartEnable = copy_src->primitiveRestartEnable;
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
@@ -4471,327 +4490,308 @@ void safe_VkPipelineMultisampleStateCreateInfo::initialize(const safe_VkPipeline
     }
 }
 
-safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo(
-    const VkPipelineDepthStencilStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo(
+    const VkPipelineRasterizationStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
       flags(in_struct->flags),
-      depthTestEnable(in_struct->depthTestEnable),
-      depthWriteEnable(in_struct->depthWriteEnable),
-      depthCompareOp(in_struct->depthCompareOp),
-      depthBoundsTestEnable(in_struct->depthBoundsTestEnable),
-      stencilTestEnable(in_struct->stencilTestEnable),
-      front(in_struct->front),
-      back(in_struct->back),
-      minDepthBounds(in_struct->minDepthBounds),
-      maxDepthBounds(in_struct->maxDepthBounds) {
+      depthClampEnable(in_struct->depthClampEnable),
+      rasterizerDiscardEnable(in_struct->rasterizerDiscardEnable),
+      polygonMode(in_struct->polygonMode),
+      cullMode(in_struct->cullMode),
+      frontFace(in_struct->frontFace),
+      depthBiasEnable(in_struct->depthBiasEnable),
+      depthBiasConstantFactor(in_struct->depthBiasConstantFactor),
+      depthBiasClamp(in_struct->depthBiasClamp),
+      depthBiasSlopeFactor(in_struct->depthBiasSlopeFactor),
+      lineWidth(in_struct->lineWidth) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
 }
 
-safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo()
-    : sType(VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO),
+safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO),
       pNext(nullptr),
       flags(),
-      depthTestEnable(),
-      depthWriteEnable(),
-      depthCompareOp(),
-      depthBoundsTestEnable(),
-      stencilTestEnable(),
-      front(),
-      back(),
-      minDepthBounds(),
-      maxDepthBounds() {}
+      depthClampEnable(),
+      rasterizerDiscardEnable(),
+      polygonMode(),
+      cullMode(),
+      frontFace(),
+      depthBiasEnable(),
+      depthBiasConstantFactor(),
+      depthBiasClamp(),
+      depthBiasSlopeFactor(),
+      lineWidth() {}
 
-safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo(
-    const safe_VkPipelineDepthStencilStateCreateInfo& copy_src) {
+safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo(
+    const safe_VkPipelineRasterizationStateCreateInfo& copy_src) {
     sType = copy_src.sType;
     flags = copy_src.flags;
-    depthTestEnable = copy_src.depthTestEnable;
-    depthWriteEnable = copy_src.depthWriteEnable;
-    depthCompareOp = copy_src.depthCompareOp;
-    depthBoundsTestEnable = copy_src.depthBoundsTestEnable;
-    stencilTestEnable = copy_src.stencilTestEnable;
-    front = copy_src.front;
-    back = copy_src.back;
-    minDepthBounds = copy_src.minDepthBounds;
-    maxDepthBounds = copy_src.maxDepthBounds;
+    depthClampEnable = copy_src.depthClampEnable;
+    rasterizerDiscardEnable = copy_src.rasterizerDiscardEnable;
+    polygonMode = copy_src.polygonMode;
+    cullMode = copy_src.cullMode;
+    frontFace = copy_src.frontFace;
+    depthBiasEnable = copy_src.depthBiasEnable;
+    depthBiasConstantFactor = copy_src.depthBiasConstantFactor;
+    depthBiasClamp = copy_src.depthBiasClamp;
+    depthBiasSlopeFactor = copy_src.depthBiasSlopeFactor;
+    lineWidth = copy_src.lineWidth;
     pNext = SafePnextCopy(copy_src.pNext);
 }
 
-safe_VkPipelineDepthStencilStateCreateInfo& safe_VkPipelineDepthStencilStateCreateInfo::operator=(
-    const safe_VkPipelineDepthStencilStateCreateInfo& copy_src) {
+safe_VkPipelineRasterizationStateCreateInfo& safe_VkPipelineRasterizationStateCreateInfo::operator=(
+    const safe_VkPipelineRasterizationStateCreateInfo& copy_src) {
     if (&copy_src == this) return *this;
 
     FreePnextChain(pNext);
 
     sType = copy_src.sType;
     flags = copy_src.flags;
-    depthTestEnable = copy_src.depthTestEnable;
-    depthWriteEnable = copy_src.depthWriteEnable;
-    depthCompareOp = copy_src.depthCompareOp;
-    depthBoundsTestEnable = copy_src.depthBoundsTestEnable;
-    stencilTestEnable = copy_src.stencilTestEnable;
-    front = copy_src.front;
-    back = copy_src.back;
-    minDepthBounds = copy_src.minDepthBounds;
-    maxDepthBounds = copy_src.maxDepthBounds;
+    depthClampEnable = copy_src.depthClampEnable;
+    rasterizerDiscardEnable = copy_src.rasterizerDiscardEnable;
+    polygonMode = copy_src.polygonMode;
+    cullMode = copy_src.cullMode;
+    frontFace = copy_src.frontFace;
+    depthBiasEnable = copy_src.depthBiasEnable;
+    depthBiasConstantFactor = copy_src.depthBiasConstantFactor;
+    depthBiasClamp = copy_src.depthBiasClamp;
+    depthBiasSlopeFactor = copy_src.depthBiasSlopeFactor;
+    lineWidth = copy_src.lineWidth;
     pNext = SafePnextCopy(copy_src.pNext);
 
     return *this;
 }
 
-safe_VkPipelineDepthStencilStateCreateInfo::~safe_VkPipelineDepthStencilStateCreateInfo() { FreePnextChain(pNext); }
+safe_VkPipelineRasterizationStateCreateInfo::~safe_VkPipelineRasterizationStateCreateInfo() { FreePnextChain(pNext); }
 
-void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct,
-                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkPipelineRasterizationStateCreateInfo::initialize(const VkPipelineRasterizationStateCreateInfo* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
     FreePnextChain(pNext);
     sType = in_struct->sType;
     flags = in_struct->flags;
-    depthTestEnable = in_struct->depthTestEnable;
-    depthWriteEnable = in_struct->depthWriteEnable;
-    depthCompareOp = in_struct->depthCompareOp;
-    depthBoundsTestEnable = in_struct->depthBoundsTestEnable;
-    stencilTestEnable = in_struct->stencilTestEnable;
-    front = in_struct->front;
-    back = in_struct->back;
-    minDepthBounds = in_struct->minDepthBounds;
-    maxDepthBounds = in_struct->maxDepthBounds;
+    depthClampEnable = in_struct->depthClampEnable;
+    rasterizerDiscardEnable = in_struct->rasterizerDiscardEnable;
+    polygonMode = in_struct->polygonMode;
+    cullMode = in_struct->cullMode;
+    frontFace = in_struct->frontFace;
+    depthBiasEnable = in_struct->depthBiasEnable;
+    depthBiasConstantFactor = in_struct->depthBiasConstantFactor;
+    depthBiasClamp = in_struct->depthBiasClamp;
+    depthBiasSlopeFactor = in_struct->depthBiasSlopeFactor;
+    lineWidth = in_struct->lineWidth;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
 }
 
-void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const safe_VkPipelineDepthStencilStateCreateInfo* copy_src,
-                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkPipelineRasterizationStateCreateInfo::initialize(const safe_VkPipelineRasterizationStateCreateInfo* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
     flags = copy_src->flags;
-    depthTestEnable = copy_src->depthTestEnable;
-    depthWriteEnable = copy_src->depthWriteEnable;
-    depthCompareOp = copy_src->depthCompareOp;
-    depthBoundsTestEnable = copy_src->depthBoundsTestEnable;
-    stencilTestEnable = copy_src->stencilTestEnable;
-    front = copy_src->front;
-    back = copy_src->back;
-    minDepthBounds = copy_src->minDepthBounds;
-    maxDepthBounds = copy_src->maxDepthBounds;
+    depthClampEnable = copy_src->depthClampEnable;
+    rasterizerDiscardEnable = copy_src->rasterizerDiscardEnable;
+    polygonMode = copy_src->polygonMode;
+    cullMode = copy_src->cullMode;
+    frontFace = copy_src->frontFace;
+    depthBiasEnable = copy_src->depthBiasEnable;
+    depthBiasConstantFactor = copy_src->depthBiasConstantFactor;
+    depthBiasClamp = copy_src->depthBiasClamp;
+    depthBiasSlopeFactor = copy_src->depthBiasSlopeFactor;
+    lineWidth = copy_src->lineWidth;
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo(
-    const VkPipelineColorBlendStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      flags(in_struct->flags),
-      logicOpEnable(in_struct->logicOpEnable),
-      logicOp(in_struct->logicOp),
-      attachmentCount(in_struct->attachmentCount),
-      pAttachments(nullptr) {
+safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo(
+    const VkPipelineTessellationStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), patchControlPoints(in_struct->patchControlPoints) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
-    if (in_struct->pAttachments) {
-        pAttachments = new VkPipelineColorBlendAttachmentState[in_struct->attachmentCount];
-        memcpy((void*)pAttachments, (void*)in_struct->pAttachments,
-               sizeof(VkPipelineColorBlendAttachmentState) * in_struct->attachmentCount);
-    }
-
-    for (uint32_t i = 0; i < 4; ++i) {
-        blendConstants[i] = in_struct->blendConstants[i];
-    }
 }
 
-safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo()
-    : sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO),
-      pNext(nullptr),
-      flags(),
-      logicOpEnable(),
-      logicOp(),
-      attachmentCount(),
-      pAttachments(nullptr) {}
+safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO), pNext(nullptr), flags(), patchControlPoints() {}
 
-safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo(
-    const safe_VkPipelineColorBlendStateCreateInfo& copy_src) {
+safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo(
+    const safe_VkPipelineTessellationStateCreateInfo& copy_src) {
     sType = copy_src.sType;
     flags = copy_src.flags;
-    logicOpEnable = copy_src.logicOpEnable;
-    logicOp = copy_src.logicOp;
-    attachmentCount = copy_src.attachmentCount;
-    pAttachments = nullptr;
+    patchControlPoints = copy_src.patchControlPoints;
     pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pAttachments) {
-        pAttachments = new VkPipelineColorBlendAttachmentState[copy_src.attachmentCount];
-        memcpy((void*)pAttachments, (void*)copy_src.pAttachments,
-               sizeof(VkPipelineColorBlendAttachmentState) * copy_src.attachmentCount);
-    }
-
-    for (uint32_t i = 0; i < 4; ++i) {
-        blendConstants[i] = copy_src.blendConstants[i];
-    }
 }
 
-safe_VkPipelineColorBlendStateCreateInfo& safe_VkPipelineColorBlendStateCreateInfo::operator=(
-    const safe_VkPipelineColorBlendStateCreateInfo& copy_src) {
+safe_VkPipelineTessellationStateCreateInfo& safe_VkPipelineTessellationStateCreateInfo::operator=(
+    const safe_VkPipelineTessellationStateCreateInfo& copy_src) {
     if (&copy_src == this) return *this;
 
-    if (pAttachments) delete[] pAttachments;
     FreePnextChain(pNext);
 
     sType = copy_src.sType;
     flags = copy_src.flags;
-    logicOpEnable = copy_src.logicOpEnable;
-    logicOp = copy_src.logicOp;
-    attachmentCount = copy_src.attachmentCount;
-    pAttachments = nullptr;
+    patchControlPoints = copy_src.patchControlPoints;
     pNext = SafePnextCopy(copy_src.pNext);
 
-    if (copy_src.pAttachments) {
-        pAttachments = new VkPipelineColorBlendAttachmentState[copy_src.attachmentCount];
-        memcpy((void*)pAttachments, (void*)copy_src.pAttachments,
-               sizeof(VkPipelineColorBlendAttachmentState) * copy_src.attachmentCount);
-    }
-
-    for (uint32_t i = 0; i < 4; ++i) {
-        blendConstants[i] = copy_src.blendConstants[i];
-    }
-
     return *this;
 }
 
-safe_VkPipelineColorBlendStateCreateInfo::~safe_VkPipelineColorBlendStateCreateInfo() {
-    if (pAttachments) delete[] pAttachments;
-    FreePnextChain(pNext);
-}
+safe_VkPipelineTessellationStateCreateInfo::~safe_VkPipelineTessellationStateCreateInfo() { FreePnextChain(pNext); }
 
-void safe_VkPipelineColorBlendStateCreateInfo::initialize(const VkPipelineColorBlendStateCreateInfo* in_struct,
-                                                          [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pAttachments) delete[] pAttachments;
+void safe_VkPipelineTessellationStateCreateInfo::initialize(const VkPipelineTessellationStateCreateInfo* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
     FreePnextChain(pNext);
     sType = in_struct->sType;
     flags = in_struct->flags;
-    logicOpEnable = in_struct->logicOpEnable;
-    logicOp = in_struct->logicOp;
-    attachmentCount = in_struct->attachmentCount;
-    pAttachments = nullptr;
+    patchControlPoints = in_struct->patchControlPoints;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
-    if (in_struct->pAttachments) {
-        pAttachments = new VkPipelineColorBlendAttachmentState[in_struct->attachmentCount];
-        memcpy((void*)pAttachments, (void*)in_struct->pAttachments,
-               sizeof(VkPipelineColorBlendAttachmentState) * in_struct->attachmentCount);
-    }
-
-    for (uint32_t i = 0; i < 4; ++i) {
-        blendConstants[i] = in_struct->blendConstants[i];
-    }
 }
 
-void safe_VkPipelineColorBlendStateCreateInfo::initialize(const safe_VkPipelineColorBlendStateCreateInfo* copy_src,
-                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkPipelineTessellationStateCreateInfo::initialize(const safe_VkPipelineTessellationStateCreateInfo* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
     flags = copy_src->flags;
-    logicOpEnable = copy_src->logicOpEnable;
-    logicOp = copy_src->logicOp;
-    attachmentCount = copy_src->attachmentCount;
-    pAttachments = nullptr;
+    patchControlPoints = copy_src->patchControlPoints;
     pNext = SafePnextCopy(copy_src->pNext);
-
-    if (copy_src->pAttachments) {
-        pAttachments = new VkPipelineColorBlendAttachmentState[copy_src->attachmentCount];
-        memcpy((void*)pAttachments, (void*)copy_src->pAttachments,
-               sizeof(VkPipelineColorBlendAttachmentState) * copy_src->attachmentCount);
-    }
-
-    for (uint32_t i = 0; i < 4; ++i) {
-        blendConstants[i] = copy_src->blendConstants[i];
-    }
 }
 
-safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct,
-                                                                             [[maybe_unused]] PNextCopyState* copy_state,
-                                                                             bool copy_pnext)
-    : sType(in_struct->sType), flags(in_struct->flags), dynamicStateCount(in_struct->dynamicStateCount), pDynamicStates(nullptr) {
+safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo(
+    const VkPipelineVertexInputStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      vertexBindingDescriptionCount(in_struct->vertexBindingDescriptionCount),
+      pVertexBindingDescriptions(nullptr),
+      vertexAttributeDescriptionCount(in_struct->vertexAttributeDescriptionCount),
+      pVertexAttributeDescriptions(nullptr) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
-    if (in_struct->pDynamicStates) {
-        pDynamicStates = new VkDynamicState[in_struct->dynamicStateCount];
-        memcpy((void*)pDynamicStates, (void*)in_struct->pDynamicStates, sizeof(VkDynamicState) * in_struct->dynamicStateCount);
+    if (in_struct->pVertexBindingDescriptions) {
+        pVertexBindingDescriptions = new VkVertexInputBindingDescription[in_struct->vertexBindingDescriptionCount];
+        memcpy((void*)pVertexBindingDescriptions, (void*)in_struct->pVertexBindingDescriptions,
+               sizeof(VkVertexInputBindingDescription) * in_struct->vertexBindingDescriptionCount);
+    }
+
+    if (in_struct->pVertexAttributeDescriptions) {
+        pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[in_struct->vertexAttributeDescriptionCount];
+        memcpy((void*)pVertexAttributeDescriptions, (void*)in_struct->pVertexAttributeDescriptions,
+               sizeof(VkVertexInputAttributeDescription) * in_struct->vertexAttributeDescriptionCount);
     }
 }
 
-safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo()
-    : sType(VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO),
+safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO),
       pNext(nullptr),
       flags(),
-      dynamicStateCount(),
-      pDynamicStates(nullptr) {}
+      vertexBindingDescriptionCount(),
+      pVertexBindingDescriptions(nullptr),
+      vertexAttributeDescriptionCount(),
+      pVertexAttributeDescriptions(nullptr) {}
 
-safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo(
-    const safe_VkPipelineDynamicStateCreateInfo& copy_src) {
+safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo(
+    const safe_VkPipelineVertexInputStateCreateInfo& copy_src) {
     sType = copy_src.sType;
     flags = copy_src.flags;
-    dynamicStateCount = copy_src.dynamicStateCount;
-    pDynamicStates = nullptr;
+    vertexBindingDescriptionCount = copy_src.vertexBindingDescriptionCount;
+    pVertexBindingDescriptions = nullptr;
+    vertexAttributeDescriptionCount = copy_src.vertexAttributeDescriptionCount;
+    pVertexAttributeDescriptions = nullptr;
     pNext = SafePnextCopy(copy_src.pNext);
 
-    if (copy_src.pDynamicStates) {
-        pDynamicStates = new VkDynamicState[copy_src.dynamicStateCount];
-        memcpy((void*)pDynamicStates, (void*)copy_src.pDynamicStates, sizeof(VkDynamicState) * copy_src.dynamicStateCount);
+    if (copy_src.pVertexBindingDescriptions) {
+        pVertexBindingDescriptions = new VkVertexInputBindingDescription[copy_src.vertexBindingDescriptionCount];
+        memcpy((void*)pVertexBindingDescriptions, (void*)copy_src.pVertexBindingDescriptions,
+               sizeof(VkVertexInputBindingDescription) * copy_src.vertexBindingDescriptionCount);
+    }
+
+    if (copy_src.pVertexAttributeDescriptions) {
+        pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[copy_src.vertexAttributeDescriptionCount];
+        memcpy((void*)pVertexAttributeDescriptions, (void*)copy_src.pVertexAttributeDescriptions,
+               sizeof(VkVertexInputAttributeDescription) * copy_src.vertexAttributeDescriptionCount);
     }
 }
 
-safe_VkPipelineDynamicStateCreateInfo& safe_VkPipelineDynamicStateCreateInfo::operator=(
-    const safe_VkPipelineDynamicStateCreateInfo& copy_src) {
+safe_VkPipelineVertexInputStateCreateInfo& safe_VkPipelineVertexInputStateCreateInfo::operator=(
+    const safe_VkPipelineVertexInputStateCreateInfo& copy_src) {
     if (&copy_src == this) return *this;
 
-    if (pDynamicStates) delete[] pDynamicStates;
+    if (pVertexBindingDescriptions) delete[] pVertexBindingDescriptions;
+    if (pVertexAttributeDescriptions) delete[] pVertexAttributeDescriptions;
     FreePnextChain(pNext);
 
     sType = copy_src.sType;
-    flags = copy_src.flags;
-    dynamicStateCount = copy_src.dynamicStateCount;
-    pDynamicStates = nullptr;
+    flags = copy_src.flags;
+    vertexBindingDescriptionCount = copy_src.vertexBindingDescriptionCount;
+    pVertexBindingDescriptions = nullptr;
+    vertexAttributeDescriptionCount = copy_src.vertexAttributeDescriptionCount;
+    pVertexAttributeDescriptions = nullptr;
     pNext = SafePnextCopy(copy_src.pNext);
 
-    if (copy_src.pDynamicStates) {
-        pDynamicStates = new VkDynamicState[copy_src.dynamicStateCount];
-        memcpy((void*)pDynamicStates, (void*)copy_src.pDynamicStates, sizeof(VkDynamicState) * copy_src.dynamicStateCount);
+    if (copy_src.pVertexBindingDescriptions) {
+        pVertexBindingDescriptions = new VkVertexInputBindingDescription[copy_src.vertexBindingDescriptionCount];
+        memcpy((void*)pVertexBindingDescriptions, (void*)copy_src.pVertexBindingDescriptions,
+               sizeof(VkVertexInputBindingDescription) * copy_src.vertexBindingDescriptionCount);
+    }
+
+    if (copy_src.pVertexAttributeDescriptions) {
+        pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[copy_src.vertexAttributeDescriptionCount];
+        memcpy((void*)pVertexAttributeDescriptions, (void*)copy_src.pVertexAttributeDescriptions,
+               sizeof(VkVertexInputAttributeDescription) * copy_src.vertexAttributeDescriptionCount);
     }
 
     return *this;
 }
 
-safe_VkPipelineDynamicStateCreateInfo::~safe_VkPipelineDynamicStateCreateInfo() {
-    if (pDynamicStates) delete[] pDynamicStates;
+safe_VkPipelineVertexInputStateCreateInfo::~safe_VkPipelineVertexInputStateCreateInfo() {
+    if (pVertexBindingDescriptions) delete[] pVertexBindingDescriptions;
+    if (pVertexAttributeDescriptions) delete[] pVertexAttributeDescriptions;
     FreePnextChain(pNext);
 }
 
-void safe_VkPipelineDynamicStateCreateInfo::initialize(const VkPipelineDynamicStateCreateInfo* in_struct,
-                                                       [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pDynamicStates) delete[] pDynamicStates;
+void safe_VkPipelineVertexInputStateCreateInfo::initialize(const VkPipelineVertexInputStateCreateInfo* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pVertexBindingDescriptions) delete[] pVertexBindingDescriptions;
+    if (pVertexAttributeDescriptions) delete[] pVertexAttributeDescriptions;
     FreePnextChain(pNext);
     sType = in_struct->sType;
     flags = in_struct->flags;
-    dynamicStateCount = in_struct->dynamicStateCount;
-    pDynamicStates = nullptr;
+    vertexBindingDescriptionCount = in_struct->vertexBindingDescriptionCount;
+    pVertexBindingDescriptions = nullptr;
+    vertexAttributeDescriptionCount = in_struct->vertexAttributeDescriptionCount;
+    pVertexAttributeDescriptions = nullptr;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
 
-    if (in_struct->pDynamicStates) {
-        pDynamicStates = new VkDynamicState[in_struct->dynamicStateCount];
-        memcpy((void*)pDynamicStates, (void*)in_struct->pDynamicStates, sizeof(VkDynamicState) * in_struct->dynamicStateCount);
+    if (in_struct->pVertexBindingDescriptions) {
+        pVertexBindingDescriptions = new VkVertexInputBindingDescription[in_struct->vertexBindingDescriptionCount];
+        memcpy((void*)pVertexBindingDescriptions, (void*)in_struct->pVertexBindingDescriptions,
+               sizeof(VkVertexInputBindingDescription) * in_struct->vertexBindingDescriptionCount);
+    }
+
+    if (in_struct->pVertexAttributeDescriptions) {
+        pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[in_struct->vertexAttributeDescriptionCount];
+        memcpy((void*)pVertexAttributeDescriptions, (void*)in_struct->pVertexAttributeDescriptions,
+               sizeof(VkVertexInputAttributeDescription) * in_struct->vertexAttributeDescriptionCount);
     }
 }
 
-void safe_VkPipelineDynamicStateCreateInfo::initialize(const safe_VkPipelineDynamicStateCreateInfo* copy_src,
-                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkPipelineVertexInputStateCreateInfo::initialize(const safe_VkPipelineVertexInputStateCreateInfo* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
     flags = copy_src->flags;
-    dynamicStateCount = copy_src->dynamicStateCount;
-    pDynamicStates = nullptr;
+    vertexBindingDescriptionCount = copy_src->vertexBindingDescriptionCount;
+    pVertexBindingDescriptions = nullptr;
+    vertexAttributeDescriptionCount = copy_src->vertexAttributeDescriptionCount;
+    pVertexAttributeDescriptions = nullptr;
     pNext = SafePnextCopy(copy_src->pNext);
 
-    if (copy_src->pDynamicStates) {
-        pDynamicStates = new VkDynamicState[copy_src->dynamicStateCount];
-        memcpy((void*)pDynamicStates, (void*)copy_src->pDynamicStates, sizeof(VkDynamicState) * copy_src->dynamicStateCount);
+    if (copy_src->pVertexBindingDescriptions) {
+        pVertexBindingDescriptions = new VkVertexInputBindingDescription[copy_src->vertexBindingDescriptionCount];
+        memcpy((void*)pVertexBindingDescriptions, (void*)copy_src->pVertexBindingDescriptions,
+               sizeof(VkVertexInputBindingDescription) * copy_src->vertexBindingDescriptionCount);
+    }
+
+    if (copy_src->pVertexAttributeDescriptions) {
+        pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[copy_src->vertexAttributeDescriptionCount];
+        memcpy((void*)pVertexAttributeDescriptions, (void*)copy_src->pVertexAttributeDescriptions,
+               sizeof(VkVertexInputAttributeDescription) * copy_src->vertexAttributeDescriptionCount);
     }
 }
 
@@ -9432,6 +9432,98 @@ void safe_VkPhysicalDeviceShaderDrawParametersFeatures::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceDriverProperties::safe_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), driverID(in_struct->driverID), conformanceVersion(in_struct->conformanceVersion) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
+        driverName[i] = in_struct->driverName[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
+        driverInfo[i] = in_struct->driverInfo[i];
+    }
+}
+
+safe_VkPhysicalDeviceDriverProperties::safe_VkPhysicalDeviceDriverProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES), pNext(nullptr), driverID(), conformanceVersion() {}
+
+safe_VkPhysicalDeviceDriverProperties::safe_VkPhysicalDeviceDriverProperties(
+    const safe_VkPhysicalDeviceDriverProperties& copy_src) {
+    sType = copy_src.sType;
+    driverID = copy_src.driverID;
+    conformanceVersion = copy_src.conformanceVersion;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
+        driverName[i] = copy_src.driverName[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
+        driverInfo[i] = copy_src.driverInfo[i];
+    }
+}
+
+safe_VkPhysicalDeviceDriverProperties& safe_VkPhysicalDeviceDriverProperties::operator=(
+    const safe_VkPhysicalDeviceDriverProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    driverID = copy_src.driverID;
+    conformanceVersion = copy_src.conformanceVersion;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
+        driverName[i] = copy_src.driverName[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
+        driverInfo[i] = copy_src.driverInfo[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDriverProperties::~safe_VkPhysicalDeviceDriverProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDriverProperties::initialize(const VkPhysicalDeviceDriverProperties* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    driverID = in_struct->driverID;
+    conformanceVersion = in_struct->conformanceVersion;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
+        driverName[i] = in_struct->driverName[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
+        driverInfo[i] = in_struct->driverInfo[i];
+    }
+}
+
+void safe_VkPhysicalDeviceDriverProperties::initialize(const safe_VkPhysicalDeviceDriverProperties* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    driverID = copy_src->driverID;
+    conformanceVersion = copy_src->conformanceVersion;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
+        driverName[i] = copy_src->driverName[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
+        driverInfo[i] = copy_src->driverInfo[i];
+    }
+}
+
 safe_VkPhysicalDeviceVulkan11Features::safe_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features* in_struct,
                                                                              [[maybe_unused]] PNextCopyState* copy_state,
                                                                              bool copy_pnext)
@@ -10517,98 +10609,6 @@ void safe_VkImageFormatListCreateInfo::initialize(const safe_VkImageFormatListCr
     }
 }
 
-safe_VkPhysicalDeviceDriverProperties::safe_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties* in_struct,
-                                                                             [[maybe_unused]] PNextCopyState* copy_state,
-                                                                             bool copy_pnext)
-    : sType(in_struct->sType), driverID(in_struct->driverID), conformanceVersion(in_struct->conformanceVersion) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
-        driverName[i] = in_struct->driverName[i];
-    }
-
-    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
-        driverInfo[i] = in_struct->driverInfo[i];
-    }
-}
-
-safe_VkPhysicalDeviceDriverProperties::safe_VkPhysicalDeviceDriverProperties()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES), pNext(nullptr), driverID(), conformanceVersion() {}
-
-safe_VkPhysicalDeviceDriverProperties::safe_VkPhysicalDeviceDriverProperties(
-    const safe_VkPhysicalDeviceDriverProperties& copy_src) {
-    sType = copy_src.sType;
-    driverID = copy_src.driverID;
-    conformanceVersion = copy_src.conformanceVersion;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
-        driverName[i] = copy_src.driverName[i];
-    }
-
-    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
-        driverInfo[i] = copy_src.driverInfo[i];
-    }
-}
-
-safe_VkPhysicalDeviceDriverProperties& safe_VkPhysicalDeviceDriverProperties::operator=(
-    const safe_VkPhysicalDeviceDriverProperties& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    driverID = copy_src.driverID;
-    conformanceVersion = copy_src.conformanceVersion;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
-        driverName[i] = copy_src.driverName[i];
-    }
-
-    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
-        driverInfo[i] = copy_src.driverInfo[i];
-    }
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceDriverProperties::~safe_VkPhysicalDeviceDriverProperties() { FreePnextChain(pNext); }
-
-void safe_VkPhysicalDeviceDriverProperties::initialize(const VkPhysicalDeviceDriverProperties* in_struct,
-                                                       [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    driverID = in_struct->driverID;
-    conformanceVersion = in_struct->conformanceVersion;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
-    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
-        driverName[i] = in_struct->driverName[i];
-    }
-
-    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
-        driverInfo[i] = in_struct->driverInfo[i];
-    }
-}
-
-void safe_VkPhysicalDeviceDriverProperties::initialize(const safe_VkPhysicalDeviceDriverProperties* copy_src,
-                                                       [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    driverID = copy_src->driverID;
-    conformanceVersion = copy_src->conformanceVersion;
-    pNext = SafePnextCopy(copy_src->pNext);
-
-    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
-        driverName[i] = copy_src->driverName[i];
-    }
-
-    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
-        driverInfo[i] = copy_src->driverInfo[i];
-    }
-}
-
 safe_VkPhysicalDeviceVulkanMemoryModelFeatures::safe_VkPhysicalDeviceVulkanMemoryModelFeatures(
     const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
@@ -13076,6 +13076,88 @@ void safe_VkSubpassDependency2::initialize(const safe_VkSubpassDependency2* copy
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkSubpassBeginInfo::safe_VkSubpassBeginInfo(const VkSubpassBeginInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                                 bool copy_pnext)
+    : sType(in_struct->sType), contents(in_struct->contents) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSubpassBeginInfo::safe_VkSubpassBeginInfo() : sType(VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO), pNext(nullptr), contents() {}
+
+safe_VkSubpassBeginInfo::safe_VkSubpassBeginInfo(const safe_VkSubpassBeginInfo& copy_src) {
+    sType = copy_src.sType;
+    contents = copy_src.contents;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSubpassBeginInfo& safe_VkSubpassBeginInfo::operator=(const safe_VkSubpassBeginInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    contents = copy_src.contents;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSubpassBeginInfo::~safe_VkSubpassBeginInfo() { FreePnextChain(pNext); }
+
+void safe_VkSubpassBeginInfo::initialize(const VkSubpassBeginInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    contents = in_struct->contents;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSubpassBeginInfo::initialize(const safe_VkSubpassBeginInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    contents = copy_src->contents;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSubpassEndInfo::safe_VkSubpassEndInfo(const VkSubpassEndInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                             bool copy_pnext)
+    : sType(in_struct->sType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSubpassEndInfo::safe_VkSubpassEndInfo() : sType(VK_STRUCTURE_TYPE_SUBPASS_END_INFO), pNext(nullptr) {}
+
+safe_VkSubpassEndInfo::safe_VkSubpassEndInfo(const safe_VkSubpassEndInfo& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSubpassEndInfo& safe_VkSubpassEndInfo::operator=(const safe_VkSubpassEndInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSubpassEndInfo::~safe_VkSubpassEndInfo() { FreePnextChain(pNext); }
+
+void safe_VkSubpassEndInfo::initialize(const VkSubpassEndInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSubpassEndInfo::initialize(const safe_VkSubpassEndInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkRenderPassCreateInfo2::safe_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2* in_struct,
                                                            [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
@@ -13307,88 +13389,6 @@ void safe_VkRenderPassCreateInfo2::initialize(const safe_VkRenderPassCreateInfo2
     }
 }
 
-safe_VkSubpassBeginInfo::safe_VkSubpassBeginInfo(const VkSubpassBeginInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
-                                                 bool copy_pnext)
-    : sType(in_struct->sType), contents(in_struct->contents) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkSubpassBeginInfo::safe_VkSubpassBeginInfo() : sType(VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO), pNext(nullptr), contents() {}
-
-safe_VkSubpassBeginInfo::safe_VkSubpassBeginInfo(const safe_VkSubpassBeginInfo& copy_src) {
-    sType = copy_src.sType;
-    contents = copy_src.contents;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkSubpassBeginInfo& safe_VkSubpassBeginInfo::operator=(const safe_VkSubpassBeginInfo& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    contents = copy_src.contents;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkSubpassBeginInfo::~safe_VkSubpassBeginInfo() { FreePnextChain(pNext); }
-
-void safe_VkSubpassBeginInfo::initialize(const VkSubpassBeginInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    contents = in_struct->contents;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkSubpassBeginInfo::initialize(const safe_VkSubpassBeginInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    contents = copy_src->contents;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkSubpassEndInfo::safe_VkSubpassEndInfo(const VkSubpassEndInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
-                                             bool copy_pnext)
-    : sType(in_struct->sType) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkSubpassEndInfo::safe_VkSubpassEndInfo() : sType(VK_STRUCTURE_TYPE_SUBPASS_END_INFO), pNext(nullptr) {}
-
-safe_VkSubpassEndInfo::safe_VkSubpassEndInfo(const safe_VkSubpassEndInfo& copy_src) {
-    sType = copy_src.sType;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkSubpassEndInfo& safe_VkSubpassEndInfo::operator=(const safe_VkSubpassEndInfo& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkSubpassEndInfo::~safe_VkSubpassEndInfo() { FreePnextChain(pNext); }
-
-void safe_VkSubpassEndInfo::initialize(const VkSubpassEndInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkSubpassEndInfo::initialize(const safe_VkSubpassEndInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkSubpassDescriptionDepthStencilResolve::safe_VkSubpassDescriptionDepthStencilResolve(
     const VkSubpassDescriptionDepthStencilResolve* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
@@ -13680,71 +13680,158 @@ safe_VkFramebufferAttachmentImageInfo::safe_VkFramebufferAttachmentImageInfo(
     }
 }
 
-safe_VkFramebufferAttachmentImageInfo& safe_VkFramebufferAttachmentImageInfo::operator=(
-    const safe_VkFramebufferAttachmentImageInfo& copy_src) {
+safe_VkFramebufferAttachmentImageInfo& safe_VkFramebufferAttachmentImageInfo::operator=(
+    const safe_VkFramebufferAttachmentImageInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pViewFormats) delete[] pViewFormats;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    usage = copy_src.usage;
+    width = copy_src.width;
+    height = copy_src.height;
+    layerCount = copy_src.layerCount;
+    viewFormatCount = copy_src.viewFormatCount;
+    pViewFormats = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pViewFormats) {
+        pViewFormats = new VkFormat[copy_src.viewFormatCount];
+        memcpy((void*)pViewFormats, (void*)copy_src.pViewFormats, sizeof(VkFormat) * copy_src.viewFormatCount);
+    }
+
+    return *this;
+}
+
+safe_VkFramebufferAttachmentImageInfo::~safe_VkFramebufferAttachmentImageInfo() {
+    if (pViewFormats) delete[] pViewFormats;
+    FreePnextChain(pNext);
+}
+
+void safe_VkFramebufferAttachmentImageInfo::initialize(const VkFramebufferAttachmentImageInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pViewFormats) delete[] pViewFormats;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    usage = in_struct->usage;
+    width = in_struct->width;
+    height = in_struct->height;
+    layerCount = in_struct->layerCount;
+    viewFormatCount = in_struct->viewFormatCount;
+    pViewFormats = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pViewFormats) {
+        pViewFormats = new VkFormat[in_struct->viewFormatCount];
+        memcpy((void*)pViewFormats, (void*)in_struct->pViewFormats, sizeof(VkFormat) * in_struct->viewFormatCount);
+    }
+}
+
+void safe_VkFramebufferAttachmentImageInfo::initialize(const safe_VkFramebufferAttachmentImageInfo* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    usage = copy_src->usage;
+    width = copy_src->width;
+    height = copy_src->height;
+    layerCount = copy_src->layerCount;
+    viewFormatCount = copy_src->viewFormatCount;
+    pViewFormats = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pViewFormats) {
+        pViewFormats = new VkFormat[copy_src->viewFormatCount];
+        memcpy((void*)pViewFormats, (void*)copy_src->pViewFormats, sizeof(VkFormat) * copy_src->viewFormatCount);
+    }
+}
+
+safe_VkRenderPassAttachmentBeginInfo::safe_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), attachmentCount(in_struct->attachmentCount), pAttachments(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (attachmentCount && in_struct->pAttachments) {
+        pAttachments = new VkImageView[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i] = in_struct->pAttachments[i];
+        }
+    }
+}
+
+safe_VkRenderPassAttachmentBeginInfo::safe_VkRenderPassAttachmentBeginInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO), pNext(nullptr), attachmentCount(), pAttachments(nullptr) {}
+
+safe_VkRenderPassAttachmentBeginInfo::safe_VkRenderPassAttachmentBeginInfo(const safe_VkRenderPassAttachmentBeginInfo& copy_src) {
+    sType = copy_src.sType;
+    attachmentCount = copy_src.attachmentCount;
+    pAttachments = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (attachmentCount && copy_src.pAttachments) {
+        pAttachments = new VkImageView[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i] = copy_src.pAttachments[i];
+        }
+    }
+}
+
+safe_VkRenderPassAttachmentBeginInfo& safe_VkRenderPassAttachmentBeginInfo::operator=(
+    const safe_VkRenderPassAttachmentBeginInfo& copy_src) {
     if (&copy_src == this) return *this;
 
-    if (pViewFormats) delete[] pViewFormats;
+    if (pAttachments) delete[] pAttachments;
     FreePnextChain(pNext);
 
     sType = copy_src.sType;
-    flags = copy_src.flags;
-    usage = copy_src.usage;
-    width = copy_src.width;
-    height = copy_src.height;
-    layerCount = copy_src.layerCount;
-    viewFormatCount = copy_src.viewFormatCount;
-    pViewFormats = nullptr;
+    attachmentCount = copy_src.attachmentCount;
+    pAttachments = nullptr;
     pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pViewFormats) {
-        pViewFormats = new VkFormat[copy_src.viewFormatCount];
-        memcpy((void*)pViewFormats, (void*)copy_src.pViewFormats, sizeof(VkFormat) * copy_src.viewFormatCount);
+    if (attachmentCount && copy_src.pAttachments) {
+        pAttachments = new VkImageView[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i] = copy_src.pAttachments[i];
+        }
     }
 
     return *this;
 }
 
-safe_VkFramebufferAttachmentImageInfo::~safe_VkFramebufferAttachmentImageInfo() {
-    if (pViewFormats) delete[] pViewFormats;
+safe_VkRenderPassAttachmentBeginInfo::~safe_VkRenderPassAttachmentBeginInfo() {
+    if (pAttachments) delete[] pAttachments;
     FreePnextChain(pNext);
 }
 
-void safe_VkFramebufferAttachmentImageInfo::initialize(const VkFramebufferAttachmentImageInfo* in_struct,
-                                                       [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pViewFormats) delete[] pViewFormats;
+void safe_VkRenderPassAttachmentBeginInfo::initialize(const VkRenderPassAttachmentBeginInfo* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAttachments) delete[] pAttachments;
     FreePnextChain(pNext);
     sType = in_struct->sType;
-    flags = in_struct->flags;
-    usage = in_struct->usage;
-    width = in_struct->width;
-    height = in_struct->height;
-    layerCount = in_struct->layerCount;
-    viewFormatCount = in_struct->viewFormatCount;
-    pViewFormats = nullptr;
+    attachmentCount = in_struct->attachmentCount;
+    pAttachments = nullptr;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
-    if (in_struct->pViewFormats) {
-        pViewFormats = new VkFormat[in_struct->viewFormatCount];
-        memcpy((void*)pViewFormats, (void*)in_struct->pViewFormats, sizeof(VkFormat) * in_struct->viewFormatCount);
+    if (attachmentCount && in_struct->pAttachments) {
+        pAttachments = new VkImageView[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i] = in_struct->pAttachments[i];
+        }
     }
 }
 
-void safe_VkFramebufferAttachmentImageInfo::initialize(const safe_VkFramebufferAttachmentImageInfo* copy_src,
-                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+void safe_VkRenderPassAttachmentBeginInfo::initialize(const safe_VkRenderPassAttachmentBeginInfo* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
-    flags = copy_src->flags;
-    usage = copy_src->usage;
-    width = copy_src->width;
-    height = copy_src->height;
-    layerCount = copy_src->layerCount;
-    viewFormatCount = copy_src->viewFormatCount;
-    pViewFormats = nullptr;
+    attachmentCount = copy_src->attachmentCount;
+    pAttachments = nullptr;
     pNext = SafePnextCopy(copy_src->pNext);
-
-    if (copy_src->pViewFormats) {
-        pViewFormats = new VkFormat[copy_src->viewFormatCount];
-        memcpy((void*)pViewFormats, (void*)copy_src->pViewFormats, sizeof(VkFormat) * copy_src->viewFormatCount);
+    if (attachmentCount && copy_src->pAttachments) {
+        pAttachments = new VkImageView[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i] = copy_src->pAttachments[i];
+        }
     }
 }
 
@@ -13838,93 +13925,6 @@ void safe_VkFramebufferAttachmentsCreateInfo::initialize(const safe_VkFramebuffe
     }
 }
 
-safe_VkRenderPassAttachmentBeginInfo::safe_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo* in_struct,
-                                                                           [[maybe_unused]] PNextCopyState* copy_state,
-                                                                           bool copy_pnext)
-    : sType(in_struct->sType), attachmentCount(in_struct->attachmentCount), pAttachments(nullptr) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    if (attachmentCount && in_struct->pAttachments) {
-        pAttachments = new VkImageView[attachmentCount];
-        for (uint32_t i = 0; i < attachmentCount; ++i) {
-            pAttachments[i] = in_struct->pAttachments[i];
-        }
-    }
-}
-
-safe_VkRenderPassAttachmentBeginInfo::safe_VkRenderPassAttachmentBeginInfo()
-    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO), pNext(nullptr), attachmentCount(), pAttachments(nullptr) {}
-
-safe_VkRenderPassAttachmentBeginInfo::safe_VkRenderPassAttachmentBeginInfo(const safe_VkRenderPassAttachmentBeginInfo& copy_src) {
-    sType = copy_src.sType;
-    attachmentCount = copy_src.attachmentCount;
-    pAttachments = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-    if (attachmentCount && copy_src.pAttachments) {
-        pAttachments = new VkImageView[attachmentCount];
-        for (uint32_t i = 0; i < attachmentCount; ++i) {
-            pAttachments[i] = copy_src.pAttachments[i];
-        }
-    }
-}
-
-safe_VkRenderPassAttachmentBeginInfo& safe_VkRenderPassAttachmentBeginInfo::operator=(
-    const safe_VkRenderPassAttachmentBeginInfo& copy_src) {
-    if (&copy_src == this) return *this;
-
-    if (pAttachments) delete[] pAttachments;
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    attachmentCount = copy_src.attachmentCount;
-    pAttachments = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-    if (attachmentCount && copy_src.pAttachments) {
-        pAttachments = new VkImageView[attachmentCount];
-        for (uint32_t i = 0; i < attachmentCount; ++i) {
-            pAttachments[i] = copy_src.pAttachments[i];
-        }
-    }
-
-    return *this;
-}
-
-safe_VkRenderPassAttachmentBeginInfo::~safe_VkRenderPassAttachmentBeginInfo() {
-    if (pAttachments) delete[] pAttachments;
-    FreePnextChain(pNext);
-}
-
-void safe_VkRenderPassAttachmentBeginInfo::initialize(const VkRenderPassAttachmentBeginInfo* in_struct,
-                                                      [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pAttachments) delete[] pAttachments;
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    attachmentCount = in_struct->attachmentCount;
-    pAttachments = nullptr;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    if (attachmentCount && in_struct->pAttachments) {
-        pAttachments = new VkImageView[attachmentCount];
-        for (uint32_t i = 0; i < attachmentCount; ++i) {
-            pAttachments[i] = in_struct->pAttachments[i];
-        }
-    }
-}
-
-void safe_VkRenderPassAttachmentBeginInfo::initialize(const safe_VkRenderPassAttachmentBeginInfo* copy_src,
-                                                      [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    attachmentCount = copy_src->attachmentCount;
-    pAttachments = nullptr;
-    pNext = SafePnextCopy(copy_src->pNext);
-    if (attachmentCount && copy_src->pAttachments) {
-        pAttachments = new VkImageView[attachmentCount];
-        for (uint32_t i = 0; i < attachmentCount; ++i) {
-            pAttachments[i] = copy_src->pAttachments[i];
-        }
-    }
-}
-
 safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
     const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
     bool copy_pnext)
@@ -19654,6 +19654,50 @@ void safe_VkPhysicalDeviceMaintenance5Properties::initialize(const safe_VkPhysic
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkSubresourceLayout2::safe_VkSubresourceLayout2(const VkSubresourceLayout2* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), subresourceLayout(in_struct->subresourceLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSubresourceLayout2::safe_VkSubresourceLayout2()
+    : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2), pNext(nullptr), subresourceLayout() {}
+
+safe_VkSubresourceLayout2::safe_VkSubresourceLayout2(const safe_VkSubresourceLayout2& copy_src) {
+    sType = copy_src.sType;
+    subresourceLayout = copy_src.subresourceLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSubresourceLayout2& safe_VkSubresourceLayout2::operator=(const safe_VkSubresourceLayout2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    subresourceLayout = copy_src.subresourceLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSubresourceLayout2::~safe_VkSubresourceLayout2() { FreePnextChain(pNext); }
+
+void safe_VkSubresourceLayout2::initialize(const VkSubresourceLayout2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    subresourceLayout = in_struct->subresourceLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSubresourceLayout2::initialize(const safe_VkSubresourceLayout2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    subresourceLayout = copy_src->subresourceLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkImageSubresource2::safe_VkImageSubresource2(const VkImageSubresource2* in_struct,
                                                    [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), imageSubresource(in_struct->imageSubresource) {
@@ -19766,50 +19810,6 @@ void safe_VkDeviceImageSubresourceInfo::initialize(const safe_VkDeviceImageSubre
     if (copy_src->pSubresource) pSubresource = new safe_VkImageSubresource2(*copy_src->pSubresource);
 }
 
-safe_VkSubresourceLayout2::safe_VkSubresourceLayout2(const VkSubresourceLayout2* in_struct,
-                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), subresourceLayout(in_struct->subresourceLayout) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkSubresourceLayout2::safe_VkSubresourceLayout2()
-    : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2), pNext(nullptr), subresourceLayout() {}
-
-safe_VkSubresourceLayout2::safe_VkSubresourceLayout2(const safe_VkSubresourceLayout2& copy_src) {
-    sType = copy_src.sType;
-    subresourceLayout = copy_src.subresourceLayout;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkSubresourceLayout2& safe_VkSubresourceLayout2::operator=(const safe_VkSubresourceLayout2& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    subresourceLayout = copy_src.subresourceLayout;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkSubresourceLayout2::~safe_VkSubresourceLayout2() { FreePnextChain(pNext); }
-
-void safe_VkSubresourceLayout2::initialize(const VkSubresourceLayout2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    subresourceLayout = in_struct->subresourceLayout;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkSubresourceLayout2::initialize(const safe_VkSubresourceLayout2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    subresourceLayout = copy_src->subresourceLayout;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkBufferUsageFlags2CreateInfo::safe_VkBufferUsageFlags2CreateInfo(const VkBufferUsageFlags2CreateInfo* in_struct,
                                                                        [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), usage(in_struct->usage) {
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 48f498b..48fc97e 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -186,6 +186,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
                 safe_pNext = new safe_VkPhysicalDeviceShaderDrawParametersFeatures(reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceDriverProperties(reinterpret_cast<const VkPhysicalDeviceDriverProperties *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
                 safe_pNext = new safe_VkPhysicalDeviceVulkan11Features(reinterpret_cast<const VkPhysicalDeviceVulkan11Features *>(pNext), copy_state, false);
                 break;
@@ -201,9 +204,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
                 safe_pNext = new safe_VkImageFormatListCreateInfo(reinterpret_cast<const VkImageFormatListCreateInfo *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
-                safe_pNext = new safe_VkPhysicalDeviceDriverProperties(reinterpret_cast<const VkPhysicalDeviceDriverProperties *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
                 safe_pNext = new safe_VkPhysicalDeviceVulkanMemoryModelFeatures(reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures *>(pNext), copy_state, false);
                 break;
@@ -285,12 +285,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
                 safe_pNext = new safe_VkPhysicalDeviceImagelessFramebufferFeatures(reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
-                safe_pNext = new safe_VkFramebufferAttachmentsCreateInfo(reinterpret_cast<const VkFramebufferAttachmentsCreateInfo *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
                 safe_pNext = new safe_VkRenderPassAttachmentBeginInfo(reinterpret_cast<const VkRenderPassAttachmentBeginInfo *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
+                safe_pNext = new safe_VkFramebufferAttachmentsCreateInfo(reinterpret_cast<const VkFramebufferAttachmentsCreateInfo *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
                 safe_pNext = new safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(pNext), copy_state, false);
                 break;
@@ -2360,6 +2360,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE:
+                safe_pNext = new safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE(reinterpret_cast<const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
                 safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(pNext), copy_state, false);
                 break;
@@ -2562,6 +2565,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderDrawParametersFeatures *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceDriverProperties *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
             delete reinterpret_cast<safe_VkPhysicalDeviceVulkan11Features *>(header);
             break;
@@ -2577,9 +2583,6 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
             delete reinterpret_cast<safe_VkImageFormatListCreateInfo *>(header);
             break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
-            delete reinterpret_cast<safe_VkPhysicalDeviceDriverProperties *>(header);
-            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
             delete reinterpret_cast<safe_VkPhysicalDeviceVulkanMemoryModelFeatures *>(header);
             break;
@@ -2661,12 +2664,12 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
             delete reinterpret_cast<safe_VkPhysicalDeviceImagelessFramebufferFeatures *>(header);
             break;
-        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
-            delete reinterpret_cast<safe_VkFramebufferAttachmentsCreateInfo *>(header);
-            break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
             delete reinterpret_cast<safe_VkRenderPassAttachmentBeginInfo *>(header);
             break;
+        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
+            delete reinterpret_cast<safe_VkFramebufferAttachmentsCreateInfo *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
             delete reinterpret_cast<safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(header);
             break;
@@ -4736,6 +4739,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE:
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE *>(header);
+            break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
             delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureKHR *>(header);
             break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index 94161c9..bf6591f 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -23455,85 +23455,85 @@ void safe_VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV::initialize(
 
 safe_VkUbmSurfaceCreateInfoSEC::safe_VkUbmSurfaceCreateInfoSEC(const VkUbmSurfaceCreateInfoSEC* in_struct,
                                                                [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), flags(in_struct->flags), ubm_device(nullptr), ubm_surface(nullptr) {
+    : sType(in_struct->sType), flags(in_struct->flags), device(nullptr), surface(nullptr) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
-    if (in_struct->ubm_device) {
-        ubm_device = new ubm_device(*in_struct->ubm_device);
+    if (in_struct->device) {
+        device = new ubm_device(*in_struct->device);
     }
 
-    if (in_struct->ubm_surface) {
-        ubm_surface = new ubm_surface(*in_struct->ubm_surface);
+    if (in_struct->surface) {
+        surface = new ubm_surface(*in_struct->surface);
     }
 }
 
 safe_VkUbmSurfaceCreateInfoSEC::safe_VkUbmSurfaceCreateInfoSEC()
-    : sType(VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC), pNext(nullptr), flags(), ubm_device(nullptr), ubm_surface(nullptr) {}
+    : sType(VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC), pNext(nullptr), flags(), device(nullptr), surface(nullptr) {}
 
 safe_VkUbmSurfaceCreateInfoSEC::safe_VkUbmSurfaceCreateInfoSEC(const safe_VkUbmSurfaceCreateInfoSEC& copy_src) {
     sType = copy_src.sType;
     flags = copy_src.flags;
-    ubm_device = nullptr;
-    ubm_surface = nullptr;
+    device = nullptr;
+    surface = nullptr;
     pNext = SafePnextCopy(copy_src.pNext);
 
-    if (copy_src.ubm_device) {
-        ubm_device = new ubm_device(*copy_src.ubm_device);
+    if (copy_src.device) {
+        device = new ubm_device(*copy_src.device);
     }
 
-    if (copy_src.ubm_surface) {
-        ubm_surface = new ubm_surface(*copy_src.ubm_surface);
+    if (copy_src.surface) {
+        surface = new ubm_surface(*copy_src.surface);
     }
 }
 
 safe_VkUbmSurfaceCreateInfoSEC& safe_VkUbmSurfaceCreateInfoSEC::operator=(const safe_VkUbmSurfaceCreateInfoSEC& copy_src) {
     if (&copy_src == this) return *this;
 
-    if (ubm_device) delete ubm_device;
-    if (ubm_surface) delete ubm_surface;
+    if (device) delete device;
+    if (surface) delete surface;
     FreePnextChain(pNext);
 
     sType = copy_src.sType;
     flags = copy_src.flags;
-    ubm_device = nullptr;
-    ubm_surface = nullptr;
+    device = nullptr;
+    surface = nullptr;
     pNext = SafePnextCopy(copy_src.pNext);
 
-    if (copy_src.ubm_device) {
-        ubm_device = new ubm_device(*copy_src.ubm_device);
+    if (copy_src.device) {
+        device = new ubm_device(*copy_src.device);
     }
 
-    if (copy_src.ubm_surface) {
-        ubm_surface = new ubm_surface(*copy_src.ubm_surface);
+    if (copy_src.surface) {
+        surface = new ubm_surface(*copy_src.surface);
     }
 
     return *this;
 }
 
 safe_VkUbmSurfaceCreateInfoSEC::~safe_VkUbmSurfaceCreateInfoSEC() {
-    if (ubm_device) delete ubm_device;
-    if (ubm_surface) delete ubm_surface;
+    if (device) delete device;
+    if (surface) delete surface;
     FreePnextChain(pNext);
 }
 
 void safe_VkUbmSurfaceCreateInfoSEC::initialize(const VkUbmSurfaceCreateInfoSEC* in_struct,
                                                 [[maybe_unused]] PNextCopyState* copy_state) {
-    if (ubm_device) delete ubm_device;
-    if (ubm_surface) delete ubm_surface;
+    if (device) delete device;
+    if (surface) delete surface;
     FreePnextChain(pNext);
     sType = in_struct->sType;
     flags = in_struct->flags;
-    ubm_device = nullptr;
-    ubm_surface = nullptr;
+    device = nullptr;
+    surface = nullptr;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
 
-    if (in_struct->ubm_device) {
-        ubm_device = new ubm_device(*in_struct->ubm_device);
+    if (in_struct->device) {
+        device = new ubm_device(*in_struct->device);
     }
 
-    if (in_struct->ubm_surface) {
-        ubm_surface = new ubm_surface(*in_struct->ubm_surface);
+    if (in_struct->surface) {
+        surface = new ubm_surface(*in_struct->surface);
     }
 }
 
@@ -23541,20 +23541,93 @@ void safe_VkUbmSurfaceCreateInfoSEC::initialize(const safe_VkUbmSurfaceCreateInf
                                                 [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
     flags = copy_src->flags;
-    ubm_device = nullptr;
-    ubm_surface = nullptr;
+    device = nullptr;
+    surface = nullptr;
     pNext = SafePnextCopy(copy_src->pNext);
 
-    if (copy_src->ubm_device) {
-        ubm_device = new ubm_device(*copy_src->ubm_device);
+    if (copy_src->device) {
+        device = new ubm_device(*copy_src->device);
     }
 
-    if (copy_src->ubm_surface) {
-        ubm_surface = new ubm_surface(*copy_src->ubm_surface);
+    if (copy_src->surface) {
+        surface = new ubm_surface(*copy_src->surface);
     }
 }
 #endif  // VK_USE_PLATFORM_UBM_SEC
 
+safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE::safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE(
+    const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderMixedFloatDotProductFloat16AccFloat32(in_struct->shaderMixedFloatDotProductFloat16AccFloat32),
+      shaderMixedFloatDotProductFloat16AccFloat16(in_struct->shaderMixedFloatDotProductFloat16AccFloat16),
+      shaderMixedFloatDotProductBFloat16Acc(in_struct->shaderMixedFloatDotProductBFloat16Acc),
+      shaderMixedFloatDotProductFloat8AccFloat32(in_struct->shaderMixedFloatDotProductFloat8AccFloat32) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE::safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE),
+      pNext(nullptr),
+      shaderMixedFloatDotProductFloat16AccFloat32(),
+      shaderMixedFloatDotProductFloat16AccFloat16(),
+      shaderMixedFloatDotProductBFloat16Acc(),
+      shaderMixedFloatDotProductFloat8AccFloat32() {}
+
+safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE::safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE(
+    const safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE& copy_src) {
+    sType = copy_src.sType;
+    shaderMixedFloatDotProductFloat16AccFloat32 = copy_src.shaderMixedFloatDotProductFloat16AccFloat32;
+    shaderMixedFloatDotProductFloat16AccFloat16 = copy_src.shaderMixedFloatDotProductFloat16AccFloat16;
+    shaderMixedFloatDotProductBFloat16Acc = copy_src.shaderMixedFloatDotProductBFloat16Acc;
+    shaderMixedFloatDotProductFloat8AccFloat32 = copy_src.shaderMixedFloatDotProductFloat8AccFloat32;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE&
+safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE::operator=(
+    const safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderMixedFloatDotProductFloat16AccFloat32 = copy_src.shaderMixedFloatDotProductFloat16AccFloat32;
+    shaderMixedFloatDotProductFloat16AccFloat16 = copy_src.shaderMixedFloatDotProductFloat16AccFloat16;
+    shaderMixedFloatDotProductBFloat16Acc = copy_src.shaderMixedFloatDotProductBFloat16Acc;
+    shaderMixedFloatDotProductFloat8AccFloat32 = copy_src.shaderMixedFloatDotProductFloat8AccFloat32;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE::~safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE::initialize(
+    const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderMixedFloatDotProductFloat16AccFloat32 = in_struct->shaderMixedFloatDotProductFloat16AccFloat32;
+    shaderMixedFloatDotProductFloat16AccFloat16 = in_struct->shaderMixedFloatDotProductFloat16AccFloat16;
+    shaderMixedFloatDotProductBFloat16Acc = in_struct->shaderMixedFloatDotProductBFloat16Acc;
+    shaderMixedFloatDotProductFloat8AccFloat32 = in_struct->shaderMixedFloatDotProductFloat8AccFloat32;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE::initialize(
+    const safe_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderMixedFloatDotProductFloat16AccFloat32 = copy_src->shaderMixedFloatDotProductFloat16AccFloat32;
+    shaderMixedFloatDotProductFloat16AccFloat16 = copy_src->shaderMixedFloatDotProductFloat16AccFloat16;
+    shaderMixedFloatDotProductBFloat16Acc = copy_src->shaderMixedFloatDotProductBFloat16Acc;
+    shaderMixedFloatDotProductFloat8AccFloat32 = copy_src->shaderMixedFloatDotProductFloat8AccFloat32;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 }  // namespace vku
 
 // NOLINTEND