Update for Vulkan-Docs 1.2.164v1.2.164

4 files changed, 789 insertions, 106 deletions

diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index c164086..0f21fb2 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -94,7 +94,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #endif
 
 
-static_assert( VK_HEADER_VERSION ==  163 , "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION ==  164 , "Wrong VK_HEADER_VERSION!" );
 
 // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
 // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
@@ -1235,6 +1235,13 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkAcquireProfilingLockKHR( device, pInfo );
     }
 
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquireWinrtDisplayNV( physicalDevice, display );
+    }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
     VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
     {
@@ -3236,6 +3243,13 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData );
     }
 
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay );
+    }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
     VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT
     {
       return ::vkImportFenceFdKHR( device, pImportFenceFdInfo );
@@ -3672,6 +3686,36 @@ namespace VULKAN_HPP_NAMESPACE
     Dispatch const * m_dispatch = nullptr;
   };
 
+  template <typename OwnerType, typename Dispatch>
+  class ObjectReleaseExt
+  {
+  public:
+    ObjectReleaseExt() = default;
+
+    ObjectReleaseExt( OwnerType owner, Dispatch const & dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) VULKAN_HPP_NOEXCEPT
+      : m_owner( owner )
+      , m_dispatch( &dispatch )
+    {}
+
+    OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_owner;
+    }
+
+  protected:
+    template <typename T>
+    void destroy( T t ) VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( m_owner && m_dispatch );
+      m_owner.releaseExt( t, *m_dispatch );
+    }
+
+  private:
+    OwnerType        m_owner    = {};
+    Dispatch const * m_dispatch = nullptr;
+  };
+
+
   template <typename OwnerType, typename PoolType, typename Dispatch>
   class PoolFree
   {
@@ -4851,6 +4895,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
     eUpdateAfterBind = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
+    eHostOnlyVALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE,
     eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT
   };
 
@@ -4860,6 +4905,7 @@ namespace VULKAN_HPP_NAMESPACE
     {
       case DescriptorPoolCreateFlagBits::eFreeDescriptorSet : return "FreeDescriptorSet";
       case DescriptorPoolCreateFlagBits::eUpdateAfterBind : return "UpdateAfterBind";
+      case DescriptorPoolCreateFlagBits::eHostOnlyVALVE : return "HostOnlyVALVE";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -4868,6 +4914,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     eUpdateAfterBindPool = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
     ePushDescriptorKHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR,
+    eHostOnlyPoolVALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE,
     eUpdateAfterBindPoolEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT
   };
 
@@ -4877,6 +4924,7 @@ namespace VULKAN_HPP_NAMESPACE
     {
       case DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool : return "UpdateAfterBindPool";
       case DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR : return "PushDescriptorKHR";
+      case DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE : return "HostOnlyPoolVALVE";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -4896,7 +4944,8 @@ namespace VULKAN_HPP_NAMESPACE
     eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
     eInlineUniformBlockEXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT,
     eAccelerationStructureKHR = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR,
-    eAccelerationStructureNV = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV
+    eAccelerationStructureNV = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV,
+    eMutableVALVE = VK_DESCRIPTOR_TYPE_MUTABLE_VALVE
   };
 
   VULKAN_HPP_INLINE std::string to_string( DescriptorType value )
@@ -4917,6 +4966,7 @@ namespace VULKAN_HPP_NAMESPACE
       case DescriptorType::eInlineUniformBlockEXT : return "InlineUniformBlockEXT";
       case DescriptorType::eAccelerationStructureKHR : return "AccelerationStructureKHR";
       case DescriptorType::eAccelerationStructureNV : return "AccelerationStructureNV";
+      case DescriptorType::eMutableVALVE : return "MutableVALVE";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -8630,6 +8680,8 @@ namespace VULKAN_HPP_NAMESPACE
     eImageResolve2KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR,
     ePhysicalDevice4444FormatsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT,
     eDirectfbSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT,
+    ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE,
+    eMutableDescriptorTypeCreateInfoVALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE,
     eAttachmentDescription2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR,
     eAttachmentDescriptionStencilLayoutKHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR,
     eAttachmentReference2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR,
@@ -9220,6 +9272,8 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eImageResolve2KHR : return "ImageResolve2KHR";
       case StructureType::ePhysicalDevice4444FormatsFeaturesEXT : return "PhysicalDevice4444FormatsFeaturesEXT";
       case StructureType::eDirectfbSurfaceCreateInfoEXT : return "DirectfbSurfaceCreateInfoEXT";
+      case StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE : return "PhysicalDeviceMutableDescriptorTypeFeaturesVALVE";
+      case StructureType::eMutableDescriptorTypeCreateInfoVALVE : return "MutableDescriptorTypeCreateInfoVALVE";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -9521,7 +9575,8 @@ namespace VULKAN_HPP_NAMESPACE
     eVSI = VK_VENDOR_ID_VSI,
     eKazan = VK_VENDOR_ID_KAZAN,
     eCodeplay = VK_VENDOR_ID_CODEPLAY,
-    eMESA = VK_VENDOR_ID_MESA
+    eMESA = VK_VENDOR_ID_MESA,
+    ePocl = VK_VENDOR_ID_POCL
   };
 
   VULKAN_HPP_INLINE std::string to_string( VendorId value )
@@ -9533,6 +9588,7 @@ namespace VULKAN_HPP_NAMESPACE
       case VendorId::eKazan : return "Kazan";
       case VendorId::eCodeplay : return "Codeplay";
       case VendorId::eMESA : return "MESA";
+      case VendorId::ePocl : return "Pocl";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -10579,7 +10635,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     enum : VkFlags
     {
-      allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet) | VkFlags(DescriptorPoolCreateFlagBits::eUpdateAfterBind)
+      allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet) | VkFlags(DescriptorPoolCreateFlagBits::eUpdateAfterBind) | VkFlags(DescriptorPoolCreateFlagBits::eHostOnlyVALVE)
     };
   };
 
@@ -10611,6 +10667,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     if ( value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet ) result += "FreeDescriptorSet | ";
     if ( value & DescriptorPoolCreateFlagBits::eUpdateAfterBind ) result += "UpdateAfterBind | ";
+    if ( value & DescriptorPoolCreateFlagBits::eHostOnlyVALVE ) result += "HostOnlyVALVE | ";
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
@@ -10637,7 +10694,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     enum : VkFlags
     {
-      allFlags = VkFlags(DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool) | VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR)
+      allFlags = VkFlags(DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool) | VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) | VkFlags(DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE)
     };
   };
 
@@ -10669,6 +10726,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     if ( value & DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool ) result += "UpdateAfterBindPool | ";
     if ( value & DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR ) result += "PushDescriptorKHR | ";
+    if ( value & DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE ) result += "HostOnlyPoolVALVE | ";
     return "{ " + result.substr(0, result.size() - 3) + " }";
   }
 
@@ -29549,12 +29607,6 @@ namespace VULKAN_HPP_NAMESPACE
     {
       *this = rhs;
     }
-
-#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
-    DescriptorSetAllocateInfo( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool_, VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorSetLayout> const & setLayouts_ )
-    : descriptorPool( descriptorPool_ ), descriptorSetCount( static_cast<uint32_t>( setLayouts_.size() ) ), pSetLayouts( setLayouts_.data() )
-    {}
-#endif  // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
 #endif // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
 
     DescriptorSetAllocateInfo & operator=( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
@@ -29593,15 +29645,6 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
-    DescriptorSetAllocateInfo & setSetLayouts( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorSetLayout> const & setLayouts_ ) VULKAN_HPP_NOEXCEPT
-    {
-      descriptorSetCount = static_cast<uint32_t>( setLayouts_.size() );
-      pSetLayouts = setLayouts_.data();
-      return *this;
-    }
-#endif  // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
-
 
     operator VkDescriptorSetAllocateInfo const&() const VULKAN_HPP_NOEXCEPT
     {
@@ -54231,6 +54274,18 @@ namespace VULKAN_HPP_NAMESPACE
 #endif
 
 
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+
+
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result acquireXlibDisplayEXT( Display* dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
@@ -54851,6 +54906,20 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
 
 
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t deviceRelativeId, VULKAN_HPP_NAMESPACE::DisplayKHR* pDisplay, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
@@ -61089,6 +61158,209 @@ namespace VULKAN_HPP_NAMESPACE
   };
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
 
+  struct MutableDescriptorTypeListVALVE
+  {
+
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR MutableDescriptorTypeListVALVE(uint32_t descriptorTypeCount_ = {}, const VULKAN_HPP_NAMESPACE::DescriptorType* pDescriptorTypes_ = {}) VULKAN_HPP_NOEXCEPT
+    : descriptorTypeCount( descriptorTypeCount_ ), pDescriptorTypes( pDescriptorTypes_ )
+    {}
+
+    VULKAN_HPP_CONSTEXPR MutableDescriptorTypeListVALVE( MutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    MutableDescriptorTypeListVALVE( VkMutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+
+#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+    MutableDescriptorTypeListVALVE( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorType> const & descriptorTypes_ )
+    : descriptorTypeCount( static_cast<uint32_t>( descriptorTypes_.size() ) ), pDescriptorTypes( descriptorTypes_.data() )
+    {}
+#endif  // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+#endif // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+
+    MutableDescriptorTypeListVALVE & operator=( VkMutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE const *>( &rhs );
+      return *this;
+    }
+
+    MutableDescriptorTypeListVALVE & operator=( MutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MutableDescriptorTypeListVALVE ) );
+      return *this;
+    }
+
+    MutableDescriptorTypeListVALVE & setDescriptorTypeCount( uint32_t descriptorTypeCount_ ) VULKAN_HPP_NOEXCEPT
+    {
+      descriptorTypeCount = descriptorTypeCount_;
+      return *this;
+    }
+
+    MutableDescriptorTypeListVALVE & setPDescriptorTypes( const VULKAN_HPP_NAMESPACE::DescriptorType* pDescriptorTypes_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pDescriptorTypes = pDescriptorTypes_;
+      return *this;
+    }
+
+#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+    MutableDescriptorTypeListVALVE & setDescriptorTypes( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorType> const & descriptorTypes_ ) VULKAN_HPP_NOEXCEPT
+    {
+      descriptorTypeCount = static_cast<uint32_t>( descriptorTypes_.size() );
+      pDescriptorTypes = descriptorTypes_.data();
+      return *this;
+    }
+#endif  // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+
+
+    operator VkMutableDescriptorTypeListVALVE const&() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkMutableDescriptorTypeListVALVE*>( this );
+    }
+
+    operator VkMutableDescriptorTypeListVALVE &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkMutableDescriptorTypeListVALVE*>( this );
+    }
+
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+    auto operator<=>( MutableDescriptorTypeListVALVE const& ) const = default;
+#else
+    bool operator==( MutableDescriptorTypeListVALVE const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( descriptorTypeCount == rhs.descriptorTypeCount )
+          && ( pDescriptorTypes == rhs.pDescriptorTypes );
+    }
+
+    bool operator!=( MutableDescriptorTypeListVALVE const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+
+
+  public:
+    uint32_t descriptorTypeCount = {};
+    const VULKAN_HPP_NAMESPACE::DescriptorType* pDescriptorTypes = {};
+
+  };
+  static_assert( sizeof( MutableDescriptorTypeListVALVE ) == sizeof( VkMutableDescriptorTypeListVALVE ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<MutableDescriptorTypeListVALVE>::value, "struct wrapper is not a standard layout!" );
+
+  struct MutableDescriptorTypeCreateInfoVALVE
+  {
+    static const bool allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMutableDescriptorTypeCreateInfoVALVE;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR MutableDescriptorTypeCreateInfoVALVE(uint32_t mutableDescriptorTypeListCount_ = {}, const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE* pMutableDescriptorTypeLists_ = {}) VULKAN_HPP_NOEXCEPT
+    : mutableDescriptorTypeListCount( mutableDescriptorTypeListCount_ ), pMutableDescriptorTypeLists( pMutableDescriptorTypeLists_ )
+    {}
+
+    VULKAN_HPP_CONSTEXPR MutableDescriptorTypeCreateInfoVALVE( MutableDescriptorTypeCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    MutableDescriptorTypeCreateInfoVALVE( VkMutableDescriptorTypeCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+
+#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+    MutableDescriptorTypeCreateInfoVALVE( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE> const & mutableDescriptorTypeLists_ )
+    : mutableDescriptorTypeListCount( static_cast<uint32_t>( mutableDescriptorTypeLists_.size() ) ), pMutableDescriptorTypeLists( mutableDescriptorTypeLists_.data() )
+    {}
+#endif  // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+#endif // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+
+    MutableDescriptorTypeCreateInfoVALVE & operator=( VkMutableDescriptorTypeCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE const *>( &rhs );
+      return *this;
+    }
+
+    MutableDescriptorTypeCreateInfoVALVE & operator=( MutableDescriptorTypeCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MutableDescriptorTypeCreateInfoVALVE ) );
+      return *this;
+    }
+
+    MutableDescriptorTypeCreateInfoVALVE & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    MutableDescriptorTypeCreateInfoVALVE & setMutableDescriptorTypeListCount( uint32_t mutableDescriptorTypeListCount_ ) VULKAN_HPP_NOEXCEPT
+    {
+      mutableDescriptorTypeListCount = mutableDescriptorTypeListCount_;
+      return *this;
+    }
+
+    MutableDescriptorTypeCreateInfoVALVE & setPMutableDescriptorTypeLists( const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE* pMutableDescriptorTypeLists_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pMutableDescriptorTypeLists = pMutableDescriptorTypeLists_;
+      return *this;
+    }
+
+#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+    MutableDescriptorTypeCreateInfoVALVE & setMutableDescriptorTypeLists( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE> const & mutableDescriptorTypeLists_ ) VULKAN_HPP_NOEXCEPT
+    {
+      mutableDescriptorTypeListCount = static_cast<uint32_t>( mutableDescriptorTypeLists_.size() );
+      pMutableDescriptorTypeLists = mutableDescriptorTypeLists_.data();
+      return *this;
+    }
+#endif  // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+
+
+    operator VkMutableDescriptorTypeCreateInfoVALVE const&() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE*>( this );
+    }
+
+    operator VkMutableDescriptorTypeCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>( this );
+    }
+
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+    auto operator<=>( MutableDescriptorTypeCreateInfoVALVE const& ) const = default;
+#else
+    bool operator==( MutableDescriptorTypeCreateInfoVALVE const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( mutableDescriptorTypeListCount == rhs.mutableDescriptorTypeListCount )
+          && ( pMutableDescriptorTypeLists == rhs.pMutableDescriptorTypeLists );
+    }
+
+    bool operator!=( MutableDescriptorTypeCreateInfoVALVE const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+
+
+  public:
+    const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMutableDescriptorTypeCreateInfoVALVE;
+    const void* pNext = {};
+    uint32_t mutableDescriptorTypeListCount = {};
+    const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE* pMutableDescriptorTypeLists = {};
+
+  };
+  static_assert( sizeof( MutableDescriptorTypeCreateInfoVALVE ) == sizeof( VkMutableDescriptorTypeCreateInfoVALVE ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<MutableDescriptorTypeCreateInfoVALVE>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eMutableDescriptorTypeCreateInfoVALVE>
+  {
+    using Type = MutableDescriptorTypeCreateInfoVALVE;
+  };
+
   union PerformanceCounterResultKHR
   {
     PerformanceCounterResultKHR( VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR const& rhs ) VULKAN_HPP_NOEXCEPT
@@ -67445,6 +67717,93 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
 
+  struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
+  {
+    static const bool allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceMutableDescriptorTypeFeaturesVALVE(VULKAN_HPP_NAMESPACE::Bool32 mutableDescriptorType_ = {}) VULKAN_HPP_NOEXCEPT
+    : mutableDescriptorType( mutableDescriptorType_ )
+    {}
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceMutableDescriptorTypeFeaturesVALVE( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceMutableDescriptorTypeFeaturesVALVE( VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+#endif // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+
+    PhysicalDeviceMutableDescriptorTypeFeaturesVALVE & operator=( VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const *>( &rhs );
+      return *this;
+    }
+
+    PhysicalDeviceMutableDescriptorTypeFeaturesVALVE & operator=( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE ) );
+      return *this;
+    }
+
+    PhysicalDeviceMutableDescriptorTypeFeaturesVALVE & setPNext( void* pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceMutableDescriptorTypeFeaturesVALVE & setMutableDescriptorType( VULKAN_HPP_NAMESPACE::Bool32 mutableDescriptorType_ ) VULKAN_HPP_NOEXCEPT
+    {
+      mutableDescriptorType = mutableDescriptorType_;
+      return *this;
+    }
+
+
+    operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const&() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>( this );
+    }
+
+    operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>( this );
+    }
+
+
+#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
+    auto operator<=>( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const& ) const = default;
+#else
+    bool operator==( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( mutableDescriptorType == rhs.mutableDescriptorType );
+    }
+
+    bool operator!=( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const& rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+
+
+  public:
+    const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
+    void* pNext = {};
+    VULKAN_HPP_NAMESPACE::Bool32 mutableDescriptorType = {};
+
+  };
+  static_assert( sizeof( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE ) == sizeof( VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE ), "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE>::value, "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE>
+  {
+    using Type = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
+  };
+
   struct PhysicalDevicePCIBusInfoPropertiesEXT
   {
     static const bool allowDuplicate = false;
@@ -89549,6 +89908,25 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d  ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
+  {
+    Result result = static_cast<Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireWinrtDisplayNV" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+
+
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display* dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d  ) const VULKAN_HPP_NOEXCEPT
@@ -91771,6 +92149,36 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
 
 
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, VULKAN_HPP_NAMESPACE::DisplayKHR* pDisplay, Dispatch const & d  ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast< VkDisplayKHR *>( pDisplay ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DisplayKHR display;
+    Result result = static_cast<Result>( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
+    return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type PhysicalDevice::getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DisplayKHR display;
+    Result result = static_cast<Result>( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
+    ObjectReleaseExt<PhysicalDevice, Dispatch> deleter( *this, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNVUnique", deleter );
+  }
+#  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d  ) const VULKAN_HPP_NOEXCEPT
@@ -92038,6 +92446,8 @@ namespace VULKAN_HPP_NAMESPACE
   template <> struct StructExtends<MemoryDedicatedRequirements, MemoryRequirements2>{ enum { value = true }; };
   template <> struct StructExtends<MemoryOpaqueCaptureAddressAllocateInfo, MemoryAllocateInfo>{ enum { value = true }; };
   template <> struct StructExtends<MemoryPriorityAllocateInfoEXT, MemoryAllocateInfo>{ enum { value = true }; };
+  template <> struct StructExtends<MutableDescriptorTypeCreateInfoVALVE, DescriptorSetLayoutCreateInfo>{ enum { value = true }; };
+  template <> struct StructExtends<MutableDescriptorTypeCreateInfoVALVE, DescriptorPoolCreateInfo>{ enum { value = true }; };
   template <> struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo>{ enum { value = true }; };
   template <> struct StructExtends<PhysicalDevice16BitStorageFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
   template <> struct StructExtends<PhysicalDevice16BitStorageFeatures, DeviceCreateInfo>{ enum { value = true }; };
@@ -92143,6 +92553,8 @@ namespace VULKAN_HPP_NAMESPACE
   template <> struct StructExtends<PhysicalDeviceMultiviewFeatures, DeviceCreateInfo>{ enum { value = true }; };
   template <> struct StructExtends<PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, PhysicalDeviceProperties2>{ enum { value = true }; };
   template <> struct StructExtends<PhysicalDeviceMultiviewProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
+  template <> struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, PhysicalDeviceFeatures2>{ enum { value = true }; };
+  template <> struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, DeviceCreateInfo>{ enum { value = true }; };
   template <> struct StructExtends<PhysicalDevicePCIBusInfoPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
   template <> struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
   template <> struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
@@ -92441,6 +92853,9 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0;
     PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0;
     PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
     PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0;
 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
@@ -92886,6 +93301,9 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0;
     PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0;
     PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
     PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0;
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0;
@@ -93005,6 +93423,9 @@ namespace VULKAN_HPP_NAMESPACE
     void init( VULKAN_HPP_NAMESPACE::Instance instanceCpp ) VULKAN_HPP_NOEXCEPT
     {
       VkInstance instance = static_cast<VkInstance>(instanceCpp);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+      vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
       vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) );
 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
@@ -93146,6 +93567,9 @@ namespace VULKAN_HPP_NAMESPACE
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
       vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) );
 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+      vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
       vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) );
       vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) );
 #ifdef VK_USE_PLATFORM_WIN32_KHR
diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h
index ec5f061..0faf4ca 100644
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
@@ -43,7 +43,7 @@ extern "C" {
 #define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0
 
 // Version of this file
-#define VK_HEADER_VERSION 163
+#define VK_HEADER_VERSION 164
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_VERSION(1, 2, VK_HEADER_VERSION)
@@ -620,6 +620,8 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = 1000337010,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000,
     VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = 1000351000,
+    VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = 1000351002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
     VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
@@ -820,6 +822,7 @@ typedef enum VkVendorId {
     VK_VENDOR_ID_KAZAN = 0x10003,
     VK_VENDOR_ID_CODEPLAY = 0x10004,
     VK_VENDOR_ID_MESA = 0x10005,
+    VK_VENDOR_ID_POCL = 0x10006,
     VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF
 } VkVendorId;
 
@@ -1429,6 +1432,7 @@ typedef enum VkDescriptorType {
     VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000,
     VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000,
     VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
+    VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = 1000351000,
     VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
 } VkDescriptorType;
 
@@ -1903,6 +1907,7 @@ typedef VkFlags VkSamplerCreateFlags;
 typedef enum VkDescriptorPoolCreateFlagBits {
     VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
     VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0x00000002,
+    VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = 0x00000004,
     VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
     VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkDescriptorPoolCreateFlagBits;
@@ -1912,6 +1917,7 @@ typedef VkFlags VkDescriptorPoolResetFlags;
 typedef enum VkDescriptorSetLayoutCreateFlagBits {
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0x00000002,
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001,
+    VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = 0x00000004,
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkDescriptorSetLayoutCreateFlagBits;
@@ -11397,6 +11403,47 @@ typedef struct VkPhysicalDevice4444FormatsFeaturesEXT {
 
 
 
+#define VK_NV_acquire_winrt_display 1
+#define VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION 1
+#define VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME "VK_NV_acquire_winrt_display"
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
+typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV(
+    VkPhysicalDevice                            physicalDevice,
+    VkDisplayKHR                                display);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    deviceRelativeId,
+    VkDisplayKHR*                               pDisplay);
+#endif
+
+
+#define VK_VALVE_mutable_descriptor_type 1
+#define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1
+#define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_VALVE_mutable_descriptor_type"
+typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           mutableDescriptorType;
+} VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
+
+typedef struct VkMutableDescriptorTypeListVALVE {
+    uint32_t                   descriptorTypeCount;
+    const VkDescriptorType*    pDescriptorTypes;
+} VkMutableDescriptorTypeListVALVE;
+
+typedef struct VkMutableDescriptorTypeCreateInfoVALVE {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    uint32_t                                   mutableDescriptorTypeListCount;
+    const VkMutableDescriptorTypeListVALVE*    pMutableDescriptorTypeLists;
+} VkMutableDescriptorTypeCreateInfoVALVE;
+
+
+
 #define VK_KHR_acceleration_structure 1
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR)
 #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 11
diff --git a/registry/validusage.json b/registry/validusage.json
index d202961..ede24ef 100644
--- a/registry/validusage.json
+++ b/registry/validusage.json
@@ -1,9 +1,9 @@
 {
   "version info": {
     "schema version": 2,
-    "api version": "1.2.163",
-    "comment": "from git branch: github-main commit: a48d8432aacf8a23de3c471d6fa074d0a326cfcc",
-    "date": "2020-11-30 07:53:12Z"
+    "api version": "1.2.164",
+    "comment": "from git branch: github-main commit: 8f718b4194ed1e0a572d37072e5558dd9ceabcb0",
+    "date": "2020-12-07 11:19:04Z"
   },
   "validation": {
     "vkGetInstanceProcAddr": {
@@ -550,7 +550,7 @@
         },
         {
           "vuid": "VUID-VkDeviceCreateInfo-pNext-pNext",
-          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDeviceDeviceMemoryReportCreateInfoEXT\">VkDeviceDeviceMemoryReportCreateInfoEXT</a>, <a href=\"#VkDeviceDiagnosticsConfigCreateInfoNV\">VkDeviceDiagnosticsConfigCreateInfoNV</a>, <a href=\"#VkDeviceGroupDeviceCreateInfo\">VkDeviceGroupDeviceCreateInfo</a>, <a href=\"#VkDeviceMemoryOverallocationCreateInfoAMD\">VkDeviceMemoryOverallocationCreateInfoAMD</a>, <a href=\"#VkDevicePrivateDataCreateInfoEXT\">VkDevicePrivateDataCreateInfoEXT</a>, <a href=\"#VkPhysicalDevice16BitStorageFeatures\">VkPhysicalDevice16BitStorageFeatures</a>, <a href=\"#VkPhysicalDevice4444FormatsFeaturesEXT\">VkPhysicalDevice4444FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDevice8BitStorageFeatures\">VkPhysicalDevice8BitStorageFeatures</a>, <a href=\"#VkPhysicalDeviceASTCDecodeFeaturesEXT\">VkPhysicalDeviceASTCDecodeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceAccelerationStructureFeaturesKHR\">VkPhysicalDeviceAccelerationStructureFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\">VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeatures\">VkPhysicalDeviceBufferDeviceAddressFeatures</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeaturesEXT\">VkPhysicalDeviceBufferDeviceAddressFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCoherentMemoryFeaturesAMD\">VkPhysicalDeviceCoherentMemoryFeaturesAMD</a>, <a href=\"#VkPhysicalDeviceComputeShaderDerivativesFeaturesNV\">VkPhysicalDeviceComputeShaderDerivativesFeaturesNV</a>, <a href=\"#VkPhysicalDeviceConditionalRenderingFeaturesEXT\">VkPhysicalDeviceConditionalRenderingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixFeaturesNV\">VkPhysicalDeviceCooperativeMatrixFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCornerSampledImageFeaturesNV\">VkPhysicalDeviceCornerSampledImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCoverageReductionModeFeaturesNV\">VkPhysicalDeviceCoverageReductionModeFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCustomBorderColorFeaturesEXT\">VkPhysicalDeviceCustomBorderColorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV\">VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDepthClipEnableFeaturesEXT\">VkPhysicalDeviceDepthClipEnableFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingFeatures\">VkPhysicalDeviceDescriptorIndexingFeatures</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV\">VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDeviceMemoryReportFeaturesEXT\">VkPhysicalDeviceDeviceMemoryReportFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDiagnosticsConfigFeaturesNV\">VkPhysicalDeviceDiagnosticsConfigFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExclusiveScissorFeaturesNV\">VkPhysicalDeviceExclusiveScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicStateFeaturesEXT\">VkPhysicalDeviceExtendedDynamicStateFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFeatures2\">VkPhysicalDeviceFeatures2</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMap2FeaturesEXT\">VkPhysicalDeviceFragmentDensityMap2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapFeaturesEXT\">VkPhysicalDeviceFragmentDensityMapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV\">VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT\">VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV\">VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateFeaturesKHR\">VkPhysicalDeviceFragmentShadingRateFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceHostQueryResetFeatures\">VkPhysicalDeviceHostQueryResetFeatures</a>, <a href=\"#VkPhysicalDeviceImageRobustnessFeaturesEXT\">VkPhysicalDeviceImageRobustnessFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImagelessFramebufferFeatures\">VkPhysicalDeviceImagelessFramebufferFeatures</a>, <a href=\"#VkPhysicalDeviceIndexTypeUint8FeaturesEXT\">VkPhysicalDeviceIndexTypeUint8FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockFeaturesEXT\">VkPhysicalDeviceInlineUniformBlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceLineRasterizationFeaturesEXT\">VkPhysicalDeviceLineRasterizationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMemoryPriorityFeaturesEXT\">VkPhysicalDeviceMemoryPriorityFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderFeaturesNV\">VkPhysicalDeviceMeshShaderFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewFeatures\">VkPhysicalDeviceMultiviewFeatures</a>, <a href=\"#VkPhysicalDevicePerformanceQueryFeaturesKHR\">VkPhysicalDevicePerformanceQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT\">VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR\">VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePortabilitySubsetFeaturesKHR\">VkPhysicalDevicePortabilitySubsetFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePrivateDataFeaturesEXT\">VkPhysicalDevicePrivateDataFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryFeatures\">VkPhysicalDeviceProtectedMemoryFeatures</a>, <a href=\"#VkPhysicalDeviceRayQueryFeaturesKHR\">VkPhysicalDeviceRayQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPipelineFeaturesKHR\">VkPhysicalDeviceRayTracingPipelineFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV\">VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV</a>, <a href=\"#VkPhysicalDeviceRobustness2FeaturesEXT\">VkPhysicalDeviceRobustness2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerYcbcrConversionFeatures\">VkPhysicalDeviceSamplerYcbcrConversionFeatures</a>, <a href=\"#VkPhysicalDeviceScalarBlockLayoutFeatures\">VkPhysicalDeviceScalarBlockLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures\">VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures</a>, <a href=\"#VkPhysicalDeviceShaderAtomicFloatFeaturesEXT\">VkPhysicalDeviceShaderAtomicFloatFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderAtomicInt64Features\">VkPhysicalDeviceShaderAtomicInt64Features</a>, <a href=\"#VkPhysicalDeviceShaderClockFeaturesKHR\">VkPhysicalDeviceShaderClockFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT\">VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderDrawParametersFeatures\">VkPhysicalDeviceShaderDrawParametersFeatures</a>, <a href=\"#VkPhysicalDeviceShaderFloat16Int8Features\">VkPhysicalDeviceShaderFloat16Int8Features</a>, <a href=\"#VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT\">VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderImageFootprintFeaturesNV\">VkPhysicalDeviceShaderImageFootprintFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL\">VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsFeaturesNV\">VkPhysicalDeviceShaderSMBuiltinsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures\">VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures</a>, <a href=\"#VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR\">VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlFeaturesEXT\">VkPhysicalDeviceSubgroupSizeControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT\">VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT\">VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreFeatures\">VkPhysicalDeviceTimelineSemaphoreFeatures</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackFeaturesEXT\">VkPhysicalDeviceTransformFeedbackFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceUniformBufferStandardLayoutFeatures\">VkPhysicalDeviceUniformBufferStandardLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceVariablePointersFeatures\">VkPhysicalDeviceVariablePointersFeatures</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT\">VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVulkan11Features\">VkPhysicalDeviceVulkan11Features</a>, <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a>, <a href=\"#VkPhysicalDeviceVulkanMemoryModelFeatures\">VkPhysicalDeviceVulkanMemoryModelFeatures</a>, or <a href=\"#VkPhysicalDeviceYcbcrImageArraysFeaturesEXT\">VkPhysicalDeviceYcbcrImageArraysFeaturesEXT</a>"
+          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDeviceDeviceMemoryReportCreateInfoEXT\">VkDeviceDeviceMemoryReportCreateInfoEXT</a>, <a href=\"#VkDeviceDiagnosticsConfigCreateInfoNV\">VkDeviceDiagnosticsConfigCreateInfoNV</a>, <a href=\"#VkDeviceGroupDeviceCreateInfo\">VkDeviceGroupDeviceCreateInfo</a>, <a href=\"#VkDeviceMemoryOverallocationCreateInfoAMD\">VkDeviceMemoryOverallocationCreateInfoAMD</a>, <a href=\"#VkDevicePrivateDataCreateInfoEXT\">VkDevicePrivateDataCreateInfoEXT</a>, <a href=\"#VkPhysicalDevice16BitStorageFeatures\">VkPhysicalDevice16BitStorageFeatures</a>, <a href=\"#VkPhysicalDevice4444FormatsFeaturesEXT\">VkPhysicalDevice4444FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDevice8BitStorageFeatures\">VkPhysicalDevice8BitStorageFeatures</a>, <a href=\"#VkPhysicalDeviceASTCDecodeFeaturesEXT\">VkPhysicalDeviceASTCDecodeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceAccelerationStructureFeaturesKHR\">VkPhysicalDeviceAccelerationStructureFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\">VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeatures\">VkPhysicalDeviceBufferDeviceAddressFeatures</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeaturesEXT\">VkPhysicalDeviceBufferDeviceAddressFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCoherentMemoryFeaturesAMD\">VkPhysicalDeviceCoherentMemoryFeaturesAMD</a>, <a href=\"#VkPhysicalDeviceComputeShaderDerivativesFeaturesNV\">VkPhysicalDeviceComputeShaderDerivativesFeaturesNV</a>, <a href=\"#VkPhysicalDeviceConditionalRenderingFeaturesEXT\">VkPhysicalDeviceConditionalRenderingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixFeaturesNV\">VkPhysicalDeviceCooperativeMatrixFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCornerSampledImageFeaturesNV\">VkPhysicalDeviceCornerSampledImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCoverageReductionModeFeaturesNV\">VkPhysicalDeviceCoverageReductionModeFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCustomBorderColorFeaturesEXT\">VkPhysicalDeviceCustomBorderColorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV\">VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDepthClipEnableFeaturesEXT\">VkPhysicalDeviceDepthClipEnableFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingFeatures\">VkPhysicalDeviceDescriptorIndexingFeatures</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV\">VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDeviceMemoryReportFeaturesEXT\">VkPhysicalDeviceDeviceMemoryReportFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDiagnosticsConfigFeaturesNV\">VkPhysicalDeviceDiagnosticsConfigFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExclusiveScissorFeaturesNV\">VkPhysicalDeviceExclusiveScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicStateFeaturesEXT\">VkPhysicalDeviceExtendedDynamicStateFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFeatures2\">VkPhysicalDeviceFeatures2</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMap2FeaturesEXT\">VkPhysicalDeviceFragmentDensityMap2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapFeaturesEXT\">VkPhysicalDeviceFragmentDensityMapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV\">VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT\">VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV\">VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateFeaturesKHR\">VkPhysicalDeviceFragmentShadingRateFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceHostQueryResetFeatures\">VkPhysicalDeviceHostQueryResetFeatures</a>, <a href=\"#VkPhysicalDeviceImageRobustnessFeaturesEXT\">VkPhysicalDeviceImageRobustnessFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImagelessFramebufferFeatures\">VkPhysicalDeviceImagelessFramebufferFeatures</a>, <a href=\"#VkPhysicalDeviceIndexTypeUint8FeaturesEXT\">VkPhysicalDeviceIndexTypeUint8FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockFeaturesEXT\">VkPhysicalDeviceInlineUniformBlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceLineRasterizationFeaturesEXT\">VkPhysicalDeviceLineRasterizationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMemoryPriorityFeaturesEXT\">VkPhysicalDeviceMemoryPriorityFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderFeaturesNV\">VkPhysicalDeviceMeshShaderFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewFeatures\">VkPhysicalDeviceMultiviewFeatures</a>, <a href=\"#VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE\">VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE</a>, <a href=\"#VkPhysicalDevicePerformanceQueryFeaturesKHR\">VkPhysicalDevicePerformanceQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT\">VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR\">VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePortabilitySubsetFeaturesKHR\">VkPhysicalDevicePortabilitySubsetFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePrivateDataFeaturesEXT\">VkPhysicalDevicePrivateDataFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryFeatures\">VkPhysicalDeviceProtectedMemoryFeatures</a>, <a href=\"#VkPhysicalDeviceRayQueryFeaturesKHR\">VkPhysicalDeviceRayQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPipelineFeaturesKHR\">VkPhysicalDeviceRayTracingPipelineFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV\">VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV</a>, <a href=\"#VkPhysicalDeviceRobustness2FeaturesEXT\">VkPhysicalDeviceRobustness2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerYcbcrConversionFeatures\">VkPhysicalDeviceSamplerYcbcrConversionFeatures</a>, <a href=\"#VkPhysicalDeviceScalarBlockLayoutFeatures\">VkPhysicalDeviceScalarBlockLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures\">VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures</a>, <a href=\"#VkPhysicalDeviceShaderAtomicFloatFeaturesEXT\">VkPhysicalDeviceShaderAtomicFloatFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderAtomicInt64Features\">VkPhysicalDeviceShaderAtomicInt64Features</a>, <a href=\"#VkPhysicalDeviceShaderClockFeaturesKHR\">VkPhysicalDeviceShaderClockFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT\">VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderDrawParametersFeatures\">VkPhysicalDeviceShaderDrawParametersFeatures</a>, <a href=\"#VkPhysicalDeviceShaderFloat16Int8Features\">VkPhysicalDeviceShaderFloat16Int8Features</a>, <a href=\"#VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT\">VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderImageFootprintFeaturesNV\">VkPhysicalDeviceShaderImageFootprintFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL\">VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsFeaturesNV\">VkPhysicalDeviceShaderSMBuiltinsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures\">VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures</a>, <a href=\"#VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR\">VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlFeaturesEXT\">VkPhysicalDeviceSubgroupSizeControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT\">VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT\">VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreFeatures\">VkPhysicalDeviceTimelineSemaphoreFeatures</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackFeaturesEXT\">VkPhysicalDeviceTransformFeedbackFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceUniformBufferStandardLayoutFeatures\">VkPhysicalDeviceUniformBufferStandardLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceVariablePointersFeatures\">VkPhysicalDeviceVariablePointersFeatures</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT\">VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVulkan11Features\">VkPhysicalDeviceVulkan11Features</a>, <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a>, <a href=\"#VkPhysicalDeviceVulkanMemoryModelFeatures\">VkPhysicalDeviceVulkanMemoryModelFeatures</a>, or <a href=\"#VkPhysicalDeviceYcbcrImageArraysFeaturesEXT\">VkPhysicalDeviceYcbcrImageArraysFeaturesEXT</a>"
         },
         {
           "vuid": "VUID-VkDeviceCreateInfo-sType-unique",
@@ -961,10 +961,6 @@
     "VkCommandBufferAllocateInfo": {
       "core": [
         {
-          "vuid": "VUID-VkCommandBufferAllocateInfo-commandBufferCount-00044",
-          "text": " <code>commandBufferCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
-        },
-        {
           "vuid": "VUID-VkCommandBufferAllocateInfo-sType-sType",
           "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO</code>"
         },
@@ -5433,22 +5429,6 @@
           "text": " For any attachment in <code>framebuffer</code> that is used by <code>renderPass</code> and is bound to memory locations that are also bound to another attachment used by <code>renderPass</code>, and if at least one of those uses causes either attachment to be written to, both attachments <strong class=\"purple\">must</strong> have had the <code>VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT</code> set"
         },
         {
-          "vuid": "VUID-vkCmdBeginRenderPass-pAttachments-04102",
-          "text": " Each element of the <code>pAttachments</code> of <code>framebuffer</code> that is referenced by any element of the <code>pInputAttachments</code> of any element of <code>pSubpasses</code> of <code>renderPass</code> <strong class=\"purple\">must</strong> have <a href=\"#resources-image-view-format-features\">image view format features</a> containing at least <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code> or <code>VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT</code>"
-        },
-        {
-          "vuid": "VUID-vkCmdBeginRenderPass-pAttachments-04103",
-          "text": " Each element of the <code>pAttachments</code> of <code>framebuffer</code> that is referenced by any element of the <code>pColorAttachments</code> of any element of <code>pSubpasses</code> of <code>renderPass</code> <strong class=\"purple\">must</strong> have <a href=\"#resources-image-view-format-features\">image view format features</a> containing <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code>"
-        },
-        {
-          "vuid": "VUID-vkCmdBeginRenderPass-pAttachments-04104",
-          "text": " Each element of the <code>pAttachments</code> of <code>framebuffer</code> that is referenced by any element of the <code>pResolveAttachments</code> of any element of <code>pSubpasses</code> of <code>renderPass</code> <strong class=\"purple\">must</strong> have <a href=\"#resources-image-view-format-features\">image view format features</a> containing <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code>"
-        },
-        {
-          "vuid": "VUID-vkCmdBeginRenderPass-pAttachments-04105",
-          "text": " Each element of the <code>pAttachments</code> of <code>framebuffer</code> that is referenced by any element of the <code>pDepthStencilAttachment</code> of any element of <code>pSubpasses</code> of <code>renderPass</code> <strong class=\"purple\">must</strong> have <a href=\"#resources-image-view-format-features\">image view format features</a> containing <code>VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT</code>"
-        },
-        {
           "vuid": "VUID-vkCmdBeginRenderPass-commandBuffer-parameter",
           "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handle"
         },
@@ -5539,22 +5519,6 @@
           "text": " For any attachment in <code>framebuffer</code> that is used by <code>renderPass</code> and is bound to memory locations that are also bound to another attachment used by <code>renderPass</code>, and if at least one of those uses causes either attachment to be written to, both attachments <strong class=\"purple\">must</strong> have had the <code>VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT</code> set"
         },
         {
-          "vuid": "VUID-vkCmdBeginRenderPass2-pAttachments-04106",
-          "text": " Each element of the <code>pAttachments</code> of <code>framebuffer</code> that is referenced by any element of the <code>pInputAttachments</code> of any element of <code>pSubpasses</code> of <code>renderPass</code> <strong class=\"purple\">must</strong> have <a href=\"#resources-image-view-format-features\">image view format features</a> contain at least <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code> or <code>VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT</code>"
-        },
-        {
-          "vuid": "VUID-vkCmdBeginRenderPass2-pAttachments-04107",
-          "text": " Each element of the <code>pAttachments</code> of <code>framebuffer</code> that is referenced by any element of the <code>pColorAttachments</code> of any element of <code>pSubpasses</code> of <code>renderPass</code> <strong class=\"purple\">must</strong> have <a href=\"#resources-image-view-format-features\">image view format features</a> contain <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code>"
-        },
-        {
-          "vuid": "VUID-vkCmdBeginRenderPass2-pAttachments-04108",
-          "text": " Each element of the <code>pAttachments</code> of <code>framebuffer</code> that is referenced by any element of the <code>pResolveAttachments</code> of any element of <code>pSubpasses</code> of <code>renderPass</code> <strong class=\"purple\">must</strong> have <a href=\"#resources-image-view-format-features\">image view format features</a> contain <code>VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT</code>"
-        },
-        {
-          "vuid": "VUID-vkCmdBeginRenderPass2-pAttachments-04109",
-          "text": " Each element of the <code>pAttachments</code> of <code>framebuffer</code> that is referenced by any element of the <code>pDepthStencilAttachment</code> of any element of <code>pSubpasses</code> of <code>renderPass</code> <strong class=\"purple\">must</strong> have <a href=\"#resources-image-view-format-features\">image view format features</a> contain <code>VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT</code>"
-        },
-        {
           "vuid": "VUID-vkCmdBeginRenderPass2-commandBuffer-parameter",
           "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handle"
         },
@@ -8521,6 +8485,10 @@
     "vkGetRayTracingShaderGroupHandlesKHR": {
       "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [
         {
+          "vuid": "VUID-vkGetRayTracingShaderGroupHandlesKHR-pipeline-04619",
+          "text": " <code>pipeline</code> <strong class=\"purple\">must</strong> be a ray tracing pipeline"
+        },
+        {
           "vuid": "VUID-vkGetRayTracingShaderGroupHandlesKHR-firstGroup-04050",
           "text": " <code>firstGroup</code> <strong class=\"purple\">must</strong> be less than the number of shader groups in <code>pipeline</code>"
         },
@@ -8563,6 +8531,10 @@
     "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR": {
       "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [
         {
+          "vuid": "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-pipeline-04620",
+          "text": " <code>pipeline</code> <strong class=\"purple\">must</strong> be a ray tracing pipeline"
+        },
+        {
           "vuid": "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-firstGroup-04051",
           "text": " <code>firstGroup</code> <strong class=\"purple\">must</strong> be less than the number of shader groups in <code>pipeline</code>"
         },
@@ -8607,6 +8579,10 @@
     "vkCompileDeferredNV": {
       "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)": [
         {
+          "vuid": "VUID-vkCompileDeferredNV-pipeline-04621",
+          "text": " <code>pipeline</code> <strong class=\"purple\">must</strong> be a ray tracing pipeline"
+        },
+        {
           "vuid": "VUID-vkCompileDeferredNV-pipeline-02237",
           "text": " <code>pipeline</code> <strong class=\"purple\">must</strong> have been created with <code>VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV</code>"
         },
@@ -8631,6 +8607,10 @@
     "vkGetRayTracingShaderGroupStackSizeKHR": {
       "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [
         {
+          "vuid": "VUID-vkGetRayTracingShaderGroupStackSizeKHR-pipeline-04622",
+          "text": " <code>pipeline</code> <strong class=\"purple\">must</strong> be a ray tracing pipeline"
+        },
+        {
           "vuid": "VUID-vkGetRayTracingShaderGroupStackSizeKHR-group-03608",
           "text": " The value of <code>group</code> must be less than the number of shader groups in <code>pipeline</code>"
         },
@@ -12630,6 +12610,12 @@
           "vuid": "VUID-VkAccelerationStructureInfoNV-pGeometries-parameter",
           "text": " If <code>geometryCount</code> is not <code>0</code>, <code>pGeometries</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>geometryCount</code> valid <a href=\"#VkGeometryNV\">VkGeometryNV</a> structures"
         }
+      ],
+      "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing)+(VK_KHR_acceleration_structure)": [
+        {
+          "vuid": "VUID-VkAccelerationStructureInfoNV-type-04623",
+          "text": " <code>type</code> <strong class=\"purple\">must</strong> not be <code>VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR</code>"
+        }
       ]
     },
     "vkCreateAccelerationStructureKHR": {
@@ -13618,7 +13604,7 @@
         },
         {
           "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-pNext-pNext",
-          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDescriptorSetLayoutBindingFlagsCreateInfo\">VkDescriptorSetLayoutBindingFlagsCreateInfo</a>"
+          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDescriptorSetLayoutBindingFlagsCreateInfo\">VkDescriptorSetLayoutBindingFlagsCreateInfo</a> or <a href=\"#VkMutableDescriptorTypeCreateInfoVALVE\">VkMutableDescriptorTypeCreateInfoVALVE</a>"
         },
         {
           "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-sType-unique",
@@ -13649,6 +13635,16 @@
           "text": " If <code>flags</code> contains <code>VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR</code>, then all elements of <code>pBindings</code> <strong class=\"purple\">must</strong> not have a <code>descriptorType</code> of <code>VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT</code>"
         }
       ],
+      "(VK_KHR_push_descriptor)+(VK_VALVE_mutable_descriptor_type)": [
+        {
+          "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-04590",
+          "text": " If <code>flags</code> contains <code>VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR</code>, <code>flags</code> <strong class=\"purple\">must</strong> not contain <code>VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE</code>"
+        },
+        {
+          "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-04591",
+          "text": " If <code>flags</code> contains <code>VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR</code>, <code>pBindings</code> <strong class=\"purple\">must</strong> not have a <code>descriptorType</code> of <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code>"
+        }
+      ],
       "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [
         {
           "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-03000",
@@ -13658,6 +13654,80 @@
           "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-03001",
           "text": " If any binding has the <code>VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT</code> bit set, then all bindings <strong class=\"purple\">must</strong> not have <code>descriptorType</code> of <code>VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC</code> or <code>VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC</code>"
         }
+      ],
+      "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)+(VK_VALVE_mutable_descriptor_type)": [
+        {
+          "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-04592",
+          "text": " If <code>flags</code> contains <code>VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT</code>, <code>flags</code> <strong class=\"purple\">must</strong> not contain <code>VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE</code>"
+        }
+      ],
+      "(VK_VALVE_mutable_descriptor_type)": [
+        {
+          "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-04593",
+          "text": " If any binding has a <code>descriptorType</code> of <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code>, then a <a href=\"#VkMutableDescriptorTypeCreateInfoVALVE\">VkMutableDescriptorTypeCreateInfoVALVE</a> <strong class=\"purple\">must</strong> be present in the <code>pNext</code> chain"
+        },
+        {
+          "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-04594",
+          "text": " If a binding has a <code>descriptorType</code> value of <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code>, then <code>pImmutableSamplers</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+        },
+        {
+          "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-mutableDescriptorType-04595",
+          "text": " If <a href=\"#VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE\">VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE</a>::<code>mutableDescriptorType</code> is not enabled, <code>pBindings</code> <strong class=\"purple\">must</strong> not contain a <code>descriptorType</code> of <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code>"
+        },
+        {
+          "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-04596",
+          "text": " If <code>flags</code> contains <code>VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE</code>, <a href=\"#VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE\">VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE</a>::<code>mutableDescriptorType</code> <strong class=\"purple\">must</strong> be enabled"
+        }
+      ]
+    },
+    "VkMutableDescriptorTypeCreateInfoVALVE": {
+      "(VK_VALVE_mutable_descriptor_type)": [
+        {
+          "vuid": "VUID-VkMutableDescriptorTypeCreateInfoVALVE-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE</code>"
+        },
+        {
+          "vuid": "VUID-VkMutableDescriptorTypeCreateInfoVALVE-pMutableDescriptorTypeLists-parameter",
+          "text": " If <code>mutableDescriptorTypeListCount</code> is not <code>0</code>, <code>pMutableDescriptorTypeLists</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>mutableDescriptorTypeListCount</code> valid <a href=\"#VkMutableDescriptorTypeListVALVE\">VkMutableDescriptorTypeListVALVE</a> structures"
+        }
+      ]
+    },
+    "VkMutableDescriptorTypeListVALVE": {
+      "(VK_VALVE_mutable_descriptor_type)": [
+        {
+          "vuid": "VUID-VkMutableDescriptorTypeListVALVE-descriptorTypeCount-04597",
+          "text": " <code>descriptorTypeCount</code> <strong class=\"purple\">must</strong> not be <code>0</code> if the corresponding binding is of <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code>"
+        },
+        {
+          "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-04598",
+          "text": " <code>pDescriptorTypes</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>descriptorTypeCount</code> valid, unique <a href=\"#VkDescriptorType\">VkDescriptorType</a> values if the given binding is of <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code> type"
+        },
+        {
+          "vuid": "VUID-VkMutableDescriptorTypeListVALVE-descriptorTypeCount-04599",
+          "text": " <code>descriptorTypeCount</code> <strong class=\"purple\">must</strong> be <code>0</code> if the corresponding binding is not of <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code>"
+        },
+        {
+          "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-04600",
+          "text": " <code>pDescriptorTypes</code> <strong class=\"purple\">must</strong> not contain <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code>"
+        },
+        {
+          "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-04601",
+          "text": " <code>pDescriptorTypes</code> <strong class=\"purple\">must</strong> not contain <code>VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC</code>"
+        },
+        {
+          "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-04602",
+          "text": " <code>pDescriptorTypes</code> <strong class=\"purple\">must</strong> not contain <code>VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC</code>"
+        },
+        {
+          "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-parameter",
+          "text": " If <code>descriptorTypeCount</code> is not <code>0</code>, <code>pDescriptorTypes</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>descriptorTypeCount</code> valid <a href=\"#VkDescriptorType\">VkDescriptorType</a> values"
+        }
+      ],
+      "(VK_VALVE_mutable_descriptor_type)+(VK_EXT_inline_uniform_block)": [
+        {
+          "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-04603",
+          "text": " <code>pDescriptorTypes</code> <strong class=\"purple\">must</strong> not contain <code>VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT</code>"
+        }
       ]
     },
     "VkDescriptorSetLayoutBinding": {
@@ -13681,6 +13751,10 @@
       ],
       "(VK_EXT_inline_uniform_block)": [
         {
+          "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-04604",
+          "text": " If the <a href=\"#features-inlineUniformBlock\">inlineUniformBlock</a> feature is not enabled, <code>descriptorType</code> <strong class=\"purple\">must</strong> not be <code>VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT</code>"
+        },
+        {
           "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-02209",
           "text": " If <code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT</code> then <code>descriptorCount</code> <strong class=\"purple\">must</strong> be a multiple of <code>4</code>"
         },
@@ -13694,6 +13768,12 @@
           "vuid": "VUID-VkDescriptorSetLayoutBinding-pImmutableSamplers-04009",
           "text": " The sampler objects indicated by <code>pImmutableSamplers</code> <strong class=\"purple\">must</strong> not have a <code>borderColor</code> with one of the values <code>VK_BORDER_COLOR_FLOAT_CUSTOM_EXT</code> or <code>VK_BORDER_COLOR_INT_CUSTOM_EXT</code>"
         }
+      ],
+      "(VK_VALVE_mutable_descriptor_type)": [
+        {
+          "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-04605",
+          "text": " If <code>descriptorType</code> is <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code>, then <code>pImmutableSamplers</code> <strong class=\"purple\">must</strong> be <code>NULL</code>."
+        }
       ]
     },
     "VkDescriptorSetLayoutBindingFlagsCreateInfo": {
@@ -14132,6 +14212,12 @@
           "vuid": "VUID-VkPipelineLayoutCreateInfo-pImmutableSamplers-03566",
           "text": " The total number of <code>pImmutableSamplers</code> created with <code>flags</code> containing <code>VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT</code> or <code>VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT</code> across all shader stages and across all elements of <code>pSetLayouts</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#limits-maxDescriptorSetSubsampledSamplers\"><code>VkPhysicalDeviceFragmentDensityMap2PropertiesEXT</code>::<code>maxDescriptorSetSubsampledSamplers</code></a>"
         }
+      ],
+      "(VK_VALVE_mutable_descriptor_type)": [
+        {
+          "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-04606",
+          "text": " Any element of <code>pSetLayouts</code> <strong class=\"purple\">must</strong> not have been created with the <code>VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE</code> bit set"
+        }
       ]
     },
     "VkPushConstantRange": {
@@ -14230,7 +14316,7 @@
         },
         {
           "vuid": "VUID-VkDescriptorPoolCreateInfo-pNext-pNext",
-          "text": " <code>pNext</code> <strong class=\"purple\">must</strong> be <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDescriptorPoolInlineUniformBlockCreateInfoEXT\">VkDescriptorPoolInlineUniformBlockCreateInfoEXT</a>"
+          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDescriptorPoolInlineUniformBlockCreateInfoEXT\">VkDescriptorPoolInlineUniformBlockCreateInfoEXT</a> or <a href=\"#VkMutableDescriptorTypeCreateInfoVALVE\">VkMutableDescriptorTypeCreateInfoVALVE</a>"
         },
         {
           "vuid": "VUID-VkDescriptorPoolCreateInfo-sType-unique",
@@ -14248,6 +14334,22 @@
           "vuid": "VUID-VkDescriptorPoolCreateInfo-poolSizeCount-arraylength",
           "text": " <code>poolSizeCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
         }
+      ],
+      "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)+(VK_VALVE_mutable_descriptor_type)": [
+        {
+          "vuid": "VUID-VkDescriptorPoolCreateInfo-flags-04607",
+          "text": " If <code>flags</code> has the <code>VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE</code> bit set, then the <code>VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT</code> bit <strong class=\"purple\">must</strong> not be set"
+        }
+      ],
+      "(VK_VALVE_mutable_descriptor_type)": [
+        {
+          "vuid": "VUID-VkDescriptorPoolCreateInfo-mutableDescriptorType-04608",
+          "text": " If <a href=\"#VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE\">VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE</a>::<code>mutableDescriptorType</code> is not enabled, <code>pPoolSizes</code> <strong class=\"purple\">must</strong> not contain a <code>descriptorType</code> of <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code>"
+        },
+        {
+          "vuid": "VUID-VkDescriptorPoolCreateInfo-flags-04609",
+          "text": " If <code>flags</code> has the <code>VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE</code> bit set, <a href=\"#VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE\">VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE</a>::<code>mutableDescriptorType</code> <strong class=\"purple\">must</strong> be enabled"
+        }
       ]
     },
     "VkDescriptorPoolInlineUniformBlockCreateInfoEXT": {
@@ -14351,6 +14453,12 @@
           "text": " If any element of <code>pSetLayouts</code> was created with the <code>VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT</code> bit set, <code>descriptorPool</code> <strong class=\"purple\">must</strong> have been created with the <code>VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT</code> flag set"
         }
       ],
+      "(VK_VALVE_mutable_descriptor_type)": [
+        {
+          "vuid": "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-04610",
+          "text": " If any element of <code>pSetLayouts</code> was created with the <code>VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE</code> bit set, <code>descriptorPool</code> <strong class=\"purple\">must</strong> have been created with the <code>VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE</code> flag set"
+        }
+      ],
       "core": [
         {
           "vuid": "VUID-VkDescriptorSetAllocateInfo-sType-sType",
@@ -14370,15 +14478,11 @@
         },
         {
           "vuid": "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-parameter",
-          "text": " <code>pSetLayouts</code> <strong class=\"purple\">must</strong> be a valid pointer to an array of <code>descriptorSetCount</code> valid <a href=\"#VkDescriptorSetLayout\">VkDescriptorSetLayout</a> handles"
-        },
-        {
-          "vuid": "VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-arraylength",
-          "text": " <code>descriptorSetCount</code> <strong class=\"purple\">must</strong> be greater than <code>0</code>"
+          "text": " <code>pSetLayouts</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <a href=\"#VkDescriptorSetLayout\">VkDescriptorSetLayout</a> handle"
         },
         {
           "vuid": "VUID-VkDescriptorSetAllocateInfo-commonparent",
-          "text": " Both of <code>descriptorPool</code>, and the elements of <code>pSetLayouts</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <a href=\"#VkDevice\">VkDevice</a>"
+          "text": " Both of <code>descriptorPool</code>, and <code>pSetLayouts</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <a href=\"#VkDevice\">VkDevice</a>"
         }
       ]
     },
@@ -14690,6 +14794,12 @@
           "vuid": "VUID-VkWriteDescriptorSet-descriptorCount-03048",
           "text": " All consecutive bindings updated via a single <code>VkWriteDescriptorSet</code> structure, except those with a <code>descriptorCount</code> of zero, <strong class=\"purple\">must</strong> have identical <a href=\"#VkDescriptorBindingFlagBits\">VkDescriptorBindingFlagBits</a>"
         }
+      ],
+      "(VK_VALVE_mutable_descriptor_type)": [
+        {
+          "vuid": "VUID-VkWriteDescriptorSet-dstSet-04611",
+          "text": " If the <code>VkDescriptorSetLayoutBinding</code> for <code>dstSet</code> at <code>dstBinding</code> is <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code>, the new active descriptor type <code>descriptorType</code> <strong class=\"purple\">must</strong> exist in the corresponding <code>pMutableDescriptorTypeLists</code> list for <code>dstBinding</code>"
+        }
       ]
     },
     "VkDescriptorBufferInfo": {
@@ -14916,6 +15026,20 @@
           "vuid": "VUID-VkCopyDescriptorSet-srcSet-01921",
           "text": " If the descriptor pool from which <code>srcSet</code> was allocated was created without the <code>VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT</code> flag set, then the descriptor pool from which <code>dstSet</code> was allocated <strong class=\"purple\">must</strong> also have been created without the <code>VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT</code> flag set"
         }
+      ],
+      "(VK_VALVE_mutable_descriptor_type)": [
+        {
+          "vuid": "VUID-VkCopyDescriptorSet-dstSet-04612",
+          "text": " If <code>VkDescriptorSetLayoutBinding</code> for <code>dstSet</code> at <code>dstBinding</code> is <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code>, the new active descriptor type <strong class=\"purple\">must</strong> exist in the corresponding <code>pMutableDescriptorTypeLists</code> list for <code>dstBinding</code> if the new active descriptor type is not <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code>"
+        },
+        {
+          "vuid": "VUID-VkCopyDescriptorSet-srcSet-04613",
+          "text": " If <code>VkDescriptorSetLayoutBinding</code> for <code>srcSet</code> at <code>srcBinding</code> is <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code> and the <code>VkDescriptorSetLayoutBinding</code> for <code>dstSet</code> at <code>dstBinding</code> is not <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code>, the active descriptor type for the source descriptor <strong class=\"purple\">must</strong> match the descriptor type of <code>dstBinding</code>"
+        },
+        {
+          "vuid": "VUID-VkCopyDescriptorSet-dstSet-04614",
+          "text": " If <code>VkDescriptorSetLayoutBinding</code> for <code>dstSet</code> at <code>dstBinding</code> is <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code>, and the new active descriptor type is <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code>, the <code>pMutableDescriptorTypeLists</code> for <code>srcBinding</code> and <code>dstBinding</code> <strong class=\"purple\">must</strong> match exactly"
+        }
       ]
     },
     "vkCreateDescriptorUpdateTemplate": {
@@ -14986,6 +15110,12 @@
           "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00353",
           "text": " If <code>templateType</code> is <code>VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR</code>, <code>set</code> <strong class=\"purple\">must</strong> be the unique set number in the pipeline layout that uses a descriptor set layout that was created with <code>VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR</code>"
         }
+      ],
+      "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_VALVE_mutable_descriptor_type)": [
+        {
+          "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-04615",
+          "text": " If <code>templateType</code> is <code>VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET</code>, <code>descriptorSetLayout</code> <strong class=\"purple\">must</strong> not contain a binding with type <code>VK_DESCRIPTOR_TYPE_MUTABLE_VALVE</code>"
+        }
       ]
     },
     "VkDescriptorUpdateTemplateEntry": {
@@ -15132,6 +15262,12 @@
           "vuid": "VUID-vkCmdBindDescriptorSets-commonparent",
           "text": " Each of <code>commandBuffer</code>, <code>layout</code>, and the elements of <code>pDescriptorSets</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <a href=\"#VkDevice\">VkDevice</a>"
         }
+      ],
+      "(VK_VALVE_mutable_descriptor_type)": [
+        {
+          "vuid": "VUID-vkCmdBindDescriptorSets-pDescriptorSets-04616",
+          "text": " Each element of <code>pDescriptorSets</code> <strong class=\"purple\">must</strong> not have been allocated from a <code>VkDescriptorPool</code> with the <code>VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE</code> flag set"
+        }
       ]
     },
     "vkCmdPushDescriptorSetKHR": {
@@ -15936,19 +16072,19 @@
         }
       ]
     },
-    "LaunchIDKHR": {
+    "LaunchIdKHR": {
       "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [
         {
-          "vuid": "VUID-LaunchIDKHR-LaunchIDKHR-04266",
-          "text": " The <code>LaunchIDKHR</code> decoration <strong class=\"purple\">must</strong> be used only within the <code>RayGenerationKHR</code>, <code>IntersectionKHR</code>, <code>AnyHitKHR</code>, <code>ClosestHitKHR</code>, or <code>MissKHR</code> {ExecutionModel}"
+          "vuid": "VUID-LaunchIdKHR-LaunchIdKHR-04266",
+          "text": " The <code>LaunchIdKHR</code> decoration <strong class=\"purple\">must</strong> be used only within the <code>RayGenerationKHR</code>, <code>IntersectionKHR</code>, <code>AnyHitKHR</code>, <code>ClosestHitKHR</code>, <code>MissKHR</code>, or <code>CallableKHR</code> {ExecutionModel}"
         },
         {
-          "vuid": "VUID-LaunchIDKHR-LaunchIDKHR-04267",
-          "text": " The variable decorated with <code>LaunchIDKHR</code> <strong class=\"purple\">must</strong> be declared using the <code>Input</code> {StorageClass}"
+          "vuid": "VUID-LaunchIdKHR-LaunchIdKHR-04267",
+          "text": " The variable decorated with <code>LaunchIdKHR</code> <strong class=\"purple\">must</strong> be declared using the <code>Input</code> {StorageClass}"
         },
         {
-          "vuid": "VUID-LaunchIDKHR-LaunchIDKHR-04268",
-          "text": " The variable decorated with <code>LaunchIDKHR</code> <strong class=\"purple\">must</strong> be declared as a three-component vector of 32-bit integer values"
+          "vuid": "VUID-LaunchIdKHR-LaunchIdKHR-04268",
+          "text": " The variable decorated with <code>LaunchIdKHR</code> <strong class=\"purple\">must</strong> be declared as a three-component vector of 32-bit integer values"
         }
       ]
     },
@@ -15956,7 +16092,7 @@
       "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [
         {
           "vuid": "VUID-LaunchSizeKHR-LaunchSizeKHR-04269",
-          "text": " The <code>LaunchSizeKHR</code> decoration <strong class=\"purple\">must</strong> be used only within the <code>RayGenerationKHR</code>, <code>IntersectionKHR</code>, <code>AnyHitKHR</code>, <code>ClosestHitKHR</code>, or <code>MissKHR</code> {ExecutionModel}"
+          "text": " The <code>LaunchSizeKHR</code> decoration <strong class=\"purple\">must</strong> be used only within the <code>RayGenerationKHR</code>, <code>IntersectionKHR</code>, <code>AnyHitKHR</code>, <code>ClosestHitKHR</code>, <code>MissKHR</code>, or <code>CallableKHR</code> {ExecutionModel}"
         },
         {
           "vuid": "VUID-LaunchSizeKHR-LaunchSizeKHR-04270",
@@ -21873,6 +22009,10 @@
         {
           "vuid": "VUID-vkCmdDraw-commandBuffer-02713",
           "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point <strong class=\"purple\">must</strong> not write to any resource"
+        },
+        {
+          "vuid": "VUID-vkCmdDraw-commandBuffer-04617",
+          "text": " If any of the shader stages of the <code>VkPipeline</code> bound to the pipeline bind point used by this command uses the <a href=\"#spirvenv-capabilities-table-RayQueryKHR\">RayQueryKHR</a> capability, then <code>commandBuffer</code> <strong class=\"purple\">must</strong> not be a protected command buffer"
         }
       ],
       "(VK_EXT_shader_image_atomic_int64)": [
@@ -22121,6 +22261,10 @@
         {
           "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-02713",
           "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point <strong class=\"purple\">must</strong> not write to any resource"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-04617",
+          "text": " If any of the shader stages of the <code>VkPipeline</code> bound to the pipeline bind point used by this command uses the <a href=\"#spirvenv-capabilities-table-RayQueryKHR\">RayQueryKHR</a> capability, then <code>commandBuffer</code> <strong class=\"purple\">must</strong> not be a protected command buffer"
         }
       ],
       "(VK_EXT_shader_image_atomic_int64)": [
@@ -27161,6 +27305,10 @@
         {
           "vuid": "VUID-vkCmdDispatch-commandBuffer-02713",
           "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point <strong class=\"purple\">must</strong> not write to any resource"
+        },
+        {
+          "vuid": "VUID-vkCmdDispatch-commandBuffer-04617",
+          "text": " If any of the shader stages of the <code>VkPipeline</code> bound to the pipeline bind point used by this command uses the <a href=\"#spirvenv-capabilities-table-RayQueryKHR\">RayQueryKHR</a> capability, then <code>commandBuffer</code> <strong class=\"purple\">must</strong> not be a protected command buffer"
         }
       ],
       "(VK_EXT_shader_image_atomic_int64)": [
@@ -29406,6 +29554,34 @@
         }
       ]
     },
+    "vkAcquireWinrtDisplayNV": {
+      "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)+(VK_NV_acquire_winrt_display)": [
+        {
+          "vuid": "VUID-vkAcquireWinrtDisplayNV-physicalDevice-parameter",
+          "text": " <code>physicalDevice</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkPhysicalDevice\">VkPhysicalDevice</a> handle"
+        },
+        {
+          "vuid": "VUID-vkAcquireWinrtDisplayNV-display-parameter",
+          "text": " <code>display</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkDisplayKHR\">VkDisplayKHR</a> handle"
+        },
+        {
+          "vuid": "VUID-vkAcquireWinrtDisplayNV-display-parent",
+          "text": " <code>display</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from <code>physicalDevice</code>"
+        }
+      ]
+    },
+    "vkGetWinrtDisplayNV": {
+      "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)+(VK_NV_acquire_winrt_display)": [
+        {
+          "vuid": "VUID-vkGetWinrtDisplayNV-physicalDevice-parameter",
+          "text": " <code>physicalDevice</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkPhysicalDevice\">VkPhysicalDevice</a> handle"
+        },
+        {
+          "vuid": "VUID-vkGetWinrtDisplayNV-pDisplay-parameter",
+          "text": " <code>pDisplay</code> <strong class=\"purple\">must</strong> be a valid pointer to a <a href=\"#VkDisplayKHR\">VkDisplayKHR</a> handle"
+        }
+      ]
+    },
     "vkReleaseDisplayEXT": {
       "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)": [
         {
@@ -30633,7 +30809,7 @@
           "text": " Both of <code>device</code>, and <code>swapChain</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from the same <a href=\"#VkInstance\">VkInstance</a>"
         },
         {
-          "vuid": "VUID-vkSetLocalDimmingAMD-XXXXX",
+          "vuid": "VUID-vkSetLocalDimmingAMD-localDimmingSupport-04618",
           "text": " It is only valid to call <a href=\"#vkSetLocalDimmingAMD\">vkSetLocalDimmingAMD</a> if <a href=\"#VkDisplayNativeHdrSurfaceCapabilitiesAMD\">VkDisplayNativeHdrSurfaceCapabilitiesAMD</a>::<code>localDimmingSupport</code> is supported"
         }
       ]
@@ -31461,6 +31637,10 @@
           "text": " Any shader group handle referenced by this call <strong class=\"purple\">must</strong> have been queried from the currently bound ray tracing shader pipeline"
         },
         {
+          "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-04624",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> not be a protected command buffer"
+        },
+        {
           "vuid": "VUID-vkCmdTraceRaysNV-maxRecursionDepth-03625",
           "text": " This command <strong class=\"purple\">must</strong> not cause a trace ray instruction to be executed from a shader invocation with a <a href=\"#ray-tracing-recursion-depth\">recursion depth</a> greater than the value of <code>maxRecursionDepth</code> used to create the bound ray tracing pipeline"
         },
@@ -31581,14 +31761,6 @@
         {
           "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-02707",
           "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
-        },
-        {
-          "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-02712",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource"
-        },
-        {
-          "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-02713",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point <strong class=\"purple\">must</strong> not write to any resource"
         }
       ],
       "(VK_EXT_shader_image_atomic_int64)": [
@@ -31839,6 +32011,10 @@
           "text": " Any hit group entries in <code>pHitShaderBindingTable</code> accessed by this call from a geometry with a <code>geometryType</code> of <code>VK_GEOMETRY_TYPE_AABBS_KHR</code> <strong class=\"purple\">must</strong> have been created with <code>VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR</code>"
         },
         {
+          "vuid": "VUID-vkCmdTraceRaysKHR-commandBuffer-04625",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> not be a protected command buffer"
+        },
+        {
           "vuid": "VUID-vkCmdTraceRaysKHR-width-03626",
           "text": " <code>width</code> <strong class=\"purple\">must</strong> be less than or equal to <span class=\"eq\"><code>VkPhysicalDeviceLimits</code>::<code>maxComputeWorkGroupCount</code>[0] {times} <code>VkPhysicalDeviceLimits</code>::<code>maxComputeWorkGroupSize</code>[0]</span>"
         },
@@ -31887,14 +32063,6 @@
         {
           "vuid": "VUID-vkCmdTraceRaysKHR-commandBuffer-02707",
           "text": " If <code>commandBuffer</code> is an unprotected command buffer, any resource accessed by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be a protected resource"
-        },
-        {
-          "vuid": "VUID-vkCmdTraceRaysKHR-commandBuffer-02712",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, any resource written to by the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not be an unprotected resource"
-        },
-        {
-          "vuid": "VUID-vkCmdTraceRaysKHR-commandBuffer-02713",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point <strong class=\"purple\">must</strong> not write to any resource"
         }
       ],
       "(VK_EXT_shader_image_atomic_int64)": [
@@ -34872,6 +35040,14 @@
         }
       ]
     },
+    "VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE": {
+      "(VK_VALVE_mutable_descriptor_type)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE</code>"
+        }
+      ]
+    },
     "VkPhysicalDeviceFragmentShadingRateFeaturesKHR": {
       "(VK_KHR_fragment_shading_rate)": [
         {
diff --git a/registry/vk.xml b/registry/vk.xml
index f6cd00c..0b9d3db 100644
--- a/registry/vk.xml
+++ b/registry/vk.xml
@@ -67,6 +67,7 @@ branch of the member gitlab server.
         <tag name="MESA"        author="Mesa open source project"      contact="Chad Versace @chadversary, Daniel Stone @fooishbar, David Airlie @airlied, Jason Ekstrand @jekstrand"/>
         <tag name="INTEL"       author="Intel Corporation"             contact="Slawek Grajewski @sgrajewski"/>
         <tag name="HUAWEI"      author="Huawei Technologies Co. Ltd."  contact="Hueilong Wang @wyvernathuawei"/>
+        <tag name="VALVE"       author="Valve Corporation"             contact="Pierre-Loup Griffais @plagman, Joshua Ashton @Joshua-Ashton, Hans-Kristian Arntzen @HansKristian-Work"/>
     </tags>
 
     <types comment="Vulkan type definitions">
@@ -136,7 +137,7 @@ branch of the member gitlab server.
         <type category="define">// Vulkan 1.2 version number
 #define <name>VK_API_VERSION_1_2</name> <type>VK_MAKE_VERSION</type>(1, 2, 0)// Patch version should always be set to 0</type>
         <type category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 163</type>
+#define <name>VK_HEADER_VERSION</name> 164</type>
         <type category="define" requires="VK_HEADER_VERSION">// Complete version of this file
 #define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_VERSION</type>(1, 2, VK_HEADER_VERSION)</type>
 
@@ -337,7 +338,7 @@ typedef void <name>CAMetalLayer</name>;
         <type requires="VkToolPurposeFlagBitsEXT"         category="bitmask">typedef <type>VkFlags</type> <name>VkToolPurposeFlagsEXT</name>;</type>
 
             <comment>Types which can be void pointers or class pointers, selected at compile time</comment>
-        <type category="handle"><type>VK_DEFINE_HANDLE</type>(<name>VkInstance</name>)</type>
+        <type category="handle"                           objtypeenum="VK_OBJECT_TYPE_INSTANCE"><type>VK_DEFINE_HANDLE</type>(<name>VkInstance</name>)</type>
         <type category="handle" parent="VkInstance"       objtypeenum="VK_OBJECT_TYPE_PHYSICAL_DEVICE"><type>VK_DEFINE_HANDLE</type>(<name>VkPhysicalDevice</name>)</type>
         <type category="handle" parent="VkPhysicalDevice" objtypeenum="VK_OBJECT_TYPE_DEVICE"><type>VK_DEFINE_HANDLE</type>(<name>VkDevice</name>)</type>
         <type category="handle" parent="VkDevice"         objtypeenum="VK_OBJECT_TYPE_QUEUE"><type>VK_DEFINE_HANDLE</type>(<name>VkQueue</name>)</type>
@@ -1082,7 +1083,7 @@ typedef void <name>CAMetalLayer</name>;
             <member optional="true">const <type>void</type>*            <name>pNext</name></member>
             <member><type>VkDescriptorPool</type>       <name>descriptorPool</name></member>
             <member><type>uint32_t</type>               <name>descriptorSetCount</name></member>
-            <member len="descriptorSetCount">const <type>VkDescriptorSetLayout</type>* <name>pSetLayouts</name></member>
+            <member>const <type>VkDescriptorSetLayout</type>* <name>pSetLayouts</name></member>
         </type>
         <type category="struct" name="VkSpecializationMapEntry">
             <member><type>uint32_t</type>                     <name>constantID</name><comment>The SpecConstant ID specified in the BIL</comment></member>
@@ -5117,6 +5118,21 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>VkDeviceSize</type>                       <name>updateScratchSize</name></member>
             <member><type>VkDeviceSize</type>                       <name>buildScratchSize</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE"><type>VkStructureType</type> <name>sType</name></member>
+            <member noautovalidity="true"><type>void</type>*                     <name>pNext</name></member>
+            <member><type>VkBool32</type>                                        <name>mutableDescriptorType</name></member>
+        </type>
+        <type category="struct" name="VkMutableDescriptorTypeListVALVE">
+            <member optional="true"><type>uint32_t</type>                                          <name>descriptorTypeCount</name></member>
+            <member len="descriptorTypeCount">const <type>VkDescriptorType</type>* <name>pDescriptorTypes</name></member>
+        </type>
+        <type category="struct" name="VkMutableDescriptorTypeCreateInfoVALVE" structextends="VkDescriptorSetLayoutCreateInfo,VkDescriptorPoolCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE"><type>VkStructureType</type> <name>sType</name></member>
+            <member>const <type>void</type>*                                                                      <name>pNext</name></member>
+            <member optional="true"><type>uint32_t</type>                                                         <name>mutableDescriptorTypeListCount</name></member>
+            <member len="mutableDescriptorTypeListCount">const <type>VkMutableDescriptorTypeListVALVE</type>* <name>pMutableDescriptorTypeLists</name></member>
+        </type>
     </types>
 
     <comment>Vulkan enumerant (token) definitions</comment>
@@ -6256,7 +6272,8 @@ typedef void <name>CAMetalLayer</name>;
         <enum value="0x10003" name="VK_VENDOR_ID_KAZAN" comment="Kazan Software Renderer"/>
         <enum value="0x10004" name="VK_VENDOR_ID_CODEPLAY" comment="Codeplay Software Ltd. vendor ID"/>
         <enum value="0x10005" name="VK_VENDOR_ID_MESA"  comment="Mesa vendor ID"/>
-            <unused start="0x10006" comment="This is the next unused available Khronos vendor ID"/>
+        <enum value="0x10006" name="VK_VENDOR_ID_POCL"  comment="PoCL vendor ID"/>
+            <unused start="0x10007" comment="This is the next unused available Khronos vendor ID"/>
     </enums>
     <enums name="VkDriverId" type="enum">
         <comment>Driver IDs are now represented as enums instead of the old
@@ -7994,6 +8011,17 @@ typedef void <name>CAMetalLayer</name>;
             <param><type>RROutput</type> <name>rrOutput</name></param>
             <param><type>VkDisplayKHR</type>* <name>pDisplay</name></param>
         </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_INITIALIZATION_FAILED">
+            <proto><type>VkResult</type> <name>vkAcquireWinrtDisplayNV</name></proto>
+            <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
+            <param><type>VkDisplayKHR</type> <name>display</name></param>
+        </command>
+        <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_INITIALIZATION_FAILED">
+            <proto><type>VkResult</type> <name>vkGetWinrtDisplayNV</name></proto>
+            <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
+            <param><type>uint32_t</type> <name>deviceRelativeId</name></param>
+            <param><type>VkDisplayKHR</type>* <name>pDisplay</name></param>
+        </command>
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
             <proto><type>VkResult</type> <name>vkDisplayPowerControlEXT</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
@@ -14357,10 +14385,12 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_ARM_extension_345&quot;"              name="VK_ARM_EXTENSION_345_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_NV_extension_346" number="346" author="NV" contact="Jeff Juliano @jjuliano" supported="disabled">
+        <extension name="VK_NV_acquire_winrt_display" number="346" type="device" requires="VK_EXT_direct_mode_display" author="NV" contact="Jeff Juliano @jjuliano" platform="win32" supported="vulkan">
             <require>
-                <enum value="0"                                             name="VK_NV_EXTENSION_346_SPEC_VERSION"/>
-                <enum value="&quot;VK_NV_extension_346&quot;"               name="VK_NV_EXTENSION_346_EXTENSION_NAME"/>
+                <enum value="1"                                             name="VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_acquire_winrt_display&quot;"       name="VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME"/>
+                <command name="vkAcquireWinrtDisplayNV"/>
+                <command name="vkGetWinrtDisplayNV"/>
             </require>
         </extension>
         <extension name="VK_EXT_directfb_surface" number="347" type="instance" requires="VK_KHR_surface" platform="directfb" supported="vulkan" author="EXT" contact="Nicolas Caramelli @caramelli">
@@ -14387,12 +14417,18 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_NV_extension_351&quot;"               name="VK_NV_EXTENSION_351_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_VALVE_extension_352" number="352" author="VALVE" contact="Joshua Ashton @Joshua-Ashton,Hans-Kristian Arntzen @HansKristian-Work" supported="disabled">
+        <extension name="VK_VALVE_mutable_descriptor_type" number="352" type="device" supported="vulkan" author="VALVE" contact="Joshua Ashton @Joshua-Ashton,Hans-Kristian Arntzen @HansKristian-Work" specialuse="d3demulation" requires="VK_KHR_maintenance3">
             <require>
-                <enum value="0"                                                name="VK_VALVE_EXTENSION_352_SPEC_VERSION"/>
-                <enum value="&quot;VK_VALVE_extension_352&quot;"               name="VK_VALVE_EXTENSION_352_EXTENSION_NAME"/>
-                <enum bitpos="2" extends="VkDescriptorPoolCreateFlagBits"      name="VK_DESCRIPTOR_POOL_RESERVED_2_BIT_VALVE"/>
-                <enum bitpos="2" extends="VkDescriptorSetLayoutCreateFlagBits" name="VK_DESCRIPTOR_SET_LAYOUT_RESERVED_2_BIT_VALVE"/>
+                <enum value="1"                                                name="VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION"/>
+                <enum value="&quot;VK_VALVE_mutable_descriptor_type&quot;"     name="VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"                     name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE"/>
+                <enum offset="2" extends="VkStructureType"                     name="VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE"/>
+                <enum offset="0" extends="VkDescriptorType"                    name="VK_DESCRIPTOR_TYPE_MUTABLE_VALVE"/>
+                <enum bitpos="2" extends="VkDescriptorPoolCreateFlagBits"      name="VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE"/>
+                <enum bitpos="2" extends="VkDescriptorSetLayoutCreateFlagBits" name="VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE"/>
+                <type name="VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE"/>
+                <type name="VkMutableDescriptorTypeListVALVE"/>
+                <type name="VkMutableDescriptorTypeCreateInfoVALVE"/>
             </require>
         </extension>
         <extension name="VK_EXT_extension_353" number="353" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="disabled">