diff --git a/third_party/vulkan/vulkan_structs.hpp b/third_party/vulkan/vulkan_structs.hpp
index e5079c4..f20e6de 100644
--- a/third_party/vulkan/vulkan_structs.hpp
+++ b/third_party/vulkan/vulkan_structs.hpp
@@ -52051,6 +52051,593 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkIndirectExecutionSetCreateInfoEXT *>( this );
     }
 
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoTypeEXT const &,
+               VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoEXT const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, type, info );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType                   sType = StructureType::eIndirectExecutionSetCreateInfoEXT;
+    const void *                                          pNext = {};
+    VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoTypeEXT type  = VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoTypeEXT::ePipelines;
+    VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoEXT     info  = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::eIndirectExecutionSetCreateInfoEXT>
+  {
+    using Type = IndirectExecutionSetCreateInfoEXT;
+  };
+
+  struct IndirectExecutionSetPipelineInfoEXT
+  {
+    using NativeType = VkIndirectExecutionSetPipelineInfoEXT;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eIndirectExecutionSetPipelineInfoEXT;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR IndirectExecutionSetPipelineInfoEXT( VULKAN_HPP_NAMESPACE::Pipeline initialPipeline_  = {},
+                                                              uint32_t                       maxPipelineCount_ = {},
+                                                              const void *                   pNext_            = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext{ pNext_ }
+      , initialPipeline{ initialPipeline_ }
+      , maxPipelineCount{ maxPipelineCount_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR IndirectExecutionSetPipelineInfoEXT( IndirectExecutionSetPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    IndirectExecutionSetPipelineInfoEXT( VkIndirectExecutionSetPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+      : IndirectExecutionSetPipelineInfoEXT( *reinterpret_cast<IndirectExecutionSetPipelineInfoEXT const *>( &rhs ) )
+    {
+    }
+
+    IndirectExecutionSetPipelineInfoEXT & operator=( IndirectExecutionSetPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    IndirectExecutionSetPipelineInfoEXT & operator=( VkIndirectExecutionSetPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::IndirectExecutionSetPipelineInfoEXT const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetPipelineInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetPipelineInfoEXT & setInitialPipeline( VULKAN_HPP_NAMESPACE::Pipeline initialPipeline_ ) VULKAN_HPP_NOEXCEPT
+    {
+      initialPipeline = initialPipeline_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetPipelineInfoEXT & setMaxPipelineCount( uint32_t maxPipelineCount_ ) VULKAN_HPP_NOEXCEPT
+    {
+      maxPipelineCount = maxPipelineCount_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    operator VkIndirectExecutionSetPipelineInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkIndirectExecutionSetPipelineInfoEXT *>( this );
+    }
+
+    operator VkIndirectExecutionSetPipelineInfoEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkIndirectExecutionSetPipelineInfoEXT *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Pipeline const &, uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, initialPipeline, maxPipelineCount );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( IndirectExecutionSetPipelineInfoEXT const & ) const = default;
+#else
+    bool operator==( IndirectExecutionSetPipelineInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( initialPipeline == rhs.initialPipeline ) && ( maxPipelineCount == rhs.maxPipelineCount );
+#  endif
+    }
+
+    bool operator!=( IndirectExecutionSetPipelineInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType            = StructureType::eIndirectExecutionSetPipelineInfoEXT;
+    const void *                        pNext            = {};
+    VULKAN_HPP_NAMESPACE::Pipeline      initialPipeline  = {};
+    uint32_t                            maxPipelineCount = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::eIndirectExecutionSetPipelineInfoEXT>
+  {
+    using Type = IndirectExecutionSetPipelineInfoEXT;
+  };
+
+  struct IndirectExecutionSetShaderLayoutInfoEXT
+  {
+    using NativeType = VkIndirectExecutionSetShaderLayoutInfoEXT;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eIndirectExecutionSetShaderLayoutInfoEXT;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR IndirectExecutionSetShaderLayoutInfoEXT( uint32_t                                          setLayoutCount_ = {},
+                                                                  const VULKAN_HPP_NAMESPACE::DescriptorSetLayout * pSetLayouts_    = {},
+                                                                  const void *                                      pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext{ pNext_ }
+      , setLayoutCount{ setLayoutCount_ }
+      , pSetLayouts{ pSetLayouts_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR IndirectExecutionSetShaderLayoutInfoEXT( IndirectExecutionSetShaderLayoutInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    IndirectExecutionSetShaderLayoutInfoEXT( VkIndirectExecutionSetShaderLayoutInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+      : IndirectExecutionSetShaderLayoutInfoEXT( *reinterpret_cast<IndirectExecutionSetShaderLayoutInfoEXT const *>( &rhs ) )
+    {
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    IndirectExecutionSetShaderLayoutInfoEXT( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorSetLayout> const & setLayouts_,
+                                             const void * pNext_ = nullptr )
+      : pNext( pNext_ ), setLayoutCount( static_cast<uint32_t>( setLayouts_.size() ) ), pSetLayouts( setLayouts_.data() )
+    {
+    }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    IndirectExecutionSetShaderLayoutInfoEXT & operator=( IndirectExecutionSetShaderLayoutInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    IndirectExecutionSetShaderLayoutInfoEXT & operator=( VkIndirectExecutionSetShaderLayoutInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderLayoutInfoEXT const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderLayoutInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderLayoutInfoEXT & setSetLayoutCount( uint32_t setLayoutCount_ ) VULKAN_HPP_NOEXCEPT
+    {
+      setLayoutCount = setLayoutCount_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderLayoutInfoEXT &
+      setPSetLayouts( const VULKAN_HPP_NAMESPACE::DescriptorSetLayout * pSetLayouts_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pSetLayouts = pSetLayouts_;
+      return *this;
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    IndirectExecutionSetShaderLayoutInfoEXT &
+      setSetLayouts( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorSetLayout> const & setLayouts_ ) VULKAN_HPP_NOEXCEPT
+    {
+      setLayoutCount = static_cast<uint32_t>( setLayouts_.size() );
+      pSetLayouts    = setLayouts_.data();
+      return *this;
+    }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    operator VkIndirectExecutionSetShaderLayoutInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkIndirectExecutionSetShaderLayoutInfoEXT *>( this );
+    }
+
+    operator VkIndirectExecutionSetShaderLayoutInfoEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkIndirectExecutionSetShaderLayoutInfoEXT *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &, const VULKAN_HPP_NAMESPACE::DescriptorSetLayout * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, setLayoutCount, pSetLayouts );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( IndirectExecutionSetShaderLayoutInfoEXT const & ) const = default;
+#else
+    bool operator==( IndirectExecutionSetShaderLayoutInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( setLayoutCount == rhs.setLayoutCount ) && ( pSetLayouts == rhs.pSetLayouts );
+#  endif
+    }
+
+    bool operator!=( IndirectExecutionSetShaderLayoutInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType               sType          = StructureType::eIndirectExecutionSetShaderLayoutInfoEXT;
+    const void *                                      pNext          = {};
+    uint32_t                                          setLayoutCount = {};
+    const VULKAN_HPP_NAMESPACE::DescriptorSetLayout * pSetLayouts    = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::eIndirectExecutionSetShaderLayoutInfoEXT>
+  {
+    using Type = IndirectExecutionSetShaderLayoutInfoEXT;
+  };
+
+  struct IndirectExecutionSetShaderInfoEXT
+  {
+    using NativeType = VkIndirectExecutionSetShaderInfoEXT;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eIndirectExecutionSetShaderInfoEXT;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR IndirectExecutionSetShaderInfoEXT( uint32_t                                                              shaderCount_            = {},
+                                                            const VULKAN_HPP_NAMESPACE::ShaderEXT *                               pInitialShaders_        = {},
+                                                            const VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderLayoutInfoEXT * pSetLayoutInfos_        = {},
+                                                            uint32_t                                                              maxShaderCount_         = {},
+                                                            uint32_t                                                              pushConstantRangeCount_ = {},
+                                                            const VULKAN_HPP_NAMESPACE::PushConstantRange *                       pPushConstantRanges_    = {},
+                                                            const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext{ pNext_ }
+      , shaderCount{ shaderCount_ }
+      , pInitialShaders{ pInitialShaders_ }
+      , pSetLayoutInfos{ pSetLayoutInfos_ }
+      , maxShaderCount{ maxShaderCount_ }
+      , pushConstantRangeCount{ pushConstantRangeCount_ }
+      , pPushConstantRanges{ pPushConstantRanges_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR IndirectExecutionSetShaderInfoEXT( IndirectExecutionSetShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    IndirectExecutionSetShaderInfoEXT( VkIndirectExecutionSetShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+      : IndirectExecutionSetShaderInfoEXT( *reinterpret_cast<IndirectExecutionSetShaderInfoEXT const *>( &rhs ) )
+    {
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    IndirectExecutionSetShaderInfoEXT(
+      VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::ShaderEXT> const &                               initialShaders_,
+      VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderLayoutInfoEXT> const & setLayoutInfos_     = {},
+      uint32_t                                                                                                                   maxShaderCount_     = {},
+      VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::PushConstantRange> const &                       pushConstantRanges_ = {},
+      const void *                                                                                                               pNext_              = nullptr )
+      : pNext( pNext_ )
+      , shaderCount( static_cast<uint32_t>( initialShaders_.size() ) )
+      , pInitialShaders( initialShaders_.data() )
+      , pSetLayoutInfos( setLayoutInfos_.data() )
+      , maxShaderCount( maxShaderCount_ )
+      , pushConstantRangeCount( static_cast<uint32_t>( pushConstantRanges_.size() ) )
+      , pPushConstantRanges( pushConstantRanges_.data() )
+    {
+#    ifdef VULKAN_HPP_NO_EXCEPTIONS
+      VULKAN_HPP_ASSERT( setLayoutInfos_.empty() || ( initialShaders_.size() == setLayoutInfos_.size() ) );
+#    else
+      if ( !setLayoutInfos_.empty() && ( initialShaders_.size() != setLayoutInfos_.size() ) )
+      {
+        throw LogicError(
+          VULKAN_HPP_NAMESPACE_STRING
+          "::IndirectExecutionSetShaderInfoEXT::IndirectExecutionSetShaderInfoEXT: !setLayoutInfos_.empty() && ( initialShaders_.size() != setLayoutInfos_.size() )" );
+      }
+#    endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+    }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    IndirectExecutionSetShaderInfoEXT & operator=( IndirectExecutionSetShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    IndirectExecutionSetShaderInfoEXT & operator=( VkIndirectExecutionSetShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderInfoEXT const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setShaderCount( uint32_t shaderCount_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderCount = shaderCount_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT &
+      setPInitialShaders( const VULKAN_HPP_NAMESPACE::ShaderEXT * pInitialShaders_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pInitialShaders = pInitialShaders_;
+      return *this;
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    IndirectExecutionSetShaderInfoEXT &
+      setInitialShaders( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::ShaderEXT> const & initialShaders_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderCount     = static_cast<uint32_t>( initialShaders_.size() );
+      pInitialShaders = initialShaders_.data();
+      return *this;
+    }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT &
+      setPSetLayoutInfos( const VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderLayoutInfoEXT * pSetLayoutInfos_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pSetLayoutInfos = pSetLayoutInfos_;
+      return *this;
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    IndirectExecutionSetShaderInfoEXT & setSetLayoutInfos(
+      VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderLayoutInfoEXT> const & setLayoutInfos_ )
+      VULKAN_HPP_NOEXCEPT
+    {
+      shaderCount     = static_cast<uint32_t>( setLayoutInfos_.size() );
+      pSetLayoutInfos = setLayoutInfos_.data();
+      return *this;
+    }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setMaxShaderCount( uint32_t maxShaderCount_ ) VULKAN_HPP_NOEXCEPT
+    {
+      maxShaderCount = maxShaderCount_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pushConstantRangeCount = pushConstantRangeCount_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT &
+      setPPushConstantRanges( const VULKAN_HPP_NAMESPACE::PushConstantRange * pPushConstantRanges_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pPushConstantRanges = pPushConstantRanges_;
+      return *this;
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    IndirectExecutionSetShaderInfoEXT & setPushConstantRanges(
+      VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::PushConstantRange> const & pushConstantRanges_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pushConstantRangeCount = static_cast<uint32_t>( pushConstantRanges_.size() );
+      pPushConstantRanges    = pushConstantRanges_.data();
+      return *this;
+    }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    operator VkIndirectExecutionSetShaderInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkIndirectExecutionSetShaderInfoEXT *>( this );
+    }
+
+    operator VkIndirectExecutionSetShaderInfoEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkIndirectExecutionSetShaderInfoEXT *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               const void * const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::ShaderEXT * const &,
+               const VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderLayoutInfoEXT * const &,
+               uint32_t const &,
+               uint32_t const &,
+               const VULKAN_HPP_NAMESPACE::PushConstantRange * const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, shaderCount, pInitialShaders, pSetLayoutInfos, maxShaderCount, pushConstantRangeCount, pPushConstantRanges );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( IndirectExecutionSetShaderInfoEXT const & ) const = default;
+#else
+    bool operator==( IndirectExecutionSetShaderInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCount == rhs.shaderCount ) && ( pInitialShaders == rhs.pInitialShaders ) &&
+             ( pSetLayoutInfos == rhs.pSetLayoutInfos ) && ( maxShaderCount == rhs.maxShaderCount ) &&
+             ( pushConstantRangeCount == rhs.pushConstantRangeCount ) && ( pPushConstantRanges == rhs.pPushConstantRanges );
+#  endif
+    }
+
+    bool operator!=( IndirectExecutionSetShaderInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType                                   sType                  = StructureType::eIndirectExecutionSetShaderInfoEXT;
+    const void *                                                          pNext                  = {};
+    uint32_t                                                              shaderCount            = {};
+    const VULKAN_HPP_NAMESPACE::ShaderEXT *                               pInitialShaders        = {};
+    const VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderLayoutInfoEXT * pSetLayoutInfos        = {};
+    uint32_t                                                              maxShaderCount         = {};
+    uint32_t                                                              pushConstantRangeCount = {};
+    const VULKAN_HPP_NAMESPACE::PushConstantRange *                       pPushConstantRanges    = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::eIndirectExecutionSetShaderInfoEXT>
+  {
+    using Type = IndirectExecutionSetShaderInfoEXT;
+  };
+
+  union IndirectExecutionSetInfoEXT
+  {
+    using NativeType = VkIndirectExecutionSetInfoEXT;
+#if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
+
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetInfoEXT( const VULKAN_HPP_NAMESPACE::IndirectExecutionSetPipelineInfoEXT * pPipelineInfo_ = {} )
+      : pPipelineInfo( pPipelineInfo_ )
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetInfoEXT( const VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderInfoEXT * pShaderInfo_ )
+      : pShaderInfo( pShaderInfo_ )
+    {
+    }
+#endif /*VULKAN_HPP_NO_UNION_CONSTRUCTORS*/
+
+#if !defined( VULKAN_HPP_NO_UNION_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetInfoEXT &
+      setPPipelineInfo( const VULKAN_HPP_NAMESPACE::IndirectExecutionSetPipelineInfoEXT * pPipelineInfo_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pPipelineInfo = pPipelineInfo_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetInfoEXT &
+      setPShaderInfo( const VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderInfoEXT * pShaderInfo_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pShaderInfo = pShaderInfo_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_UNION_SETTERS*/
+
+    operator VkIndirectExecutionSetInfoEXT const &() const
+    {
+      return *reinterpret_cast<const VkIndirectExecutionSetInfoEXT *>( this );
+    }
+
+    operator VkIndirectExecutionSetInfoEXT &()
+    {
+      return *reinterpret_cast<VkIndirectExecutionSetInfoEXT *>( this );
+    }
+
+#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+    const VULKAN_HPP_NAMESPACE::IndirectExecutionSetPipelineInfoEXT * pPipelineInfo;
+    const VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderInfoEXT *   pShaderInfo;
+#else
+    const VkIndirectExecutionSetPipelineInfoEXT * pPipelineInfo;
+    const VkIndirectExecutionSetShaderInfoEXT *   pShaderInfo;
+#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
+  };
+
+  struct IndirectExecutionSetCreateInfoEXT
+  {
+    using NativeType = VkIndirectExecutionSetCreateInfoEXT;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eIndirectExecutionSetCreateInfoEXT;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT(
+      VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoTypeEXT type_  = VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoTypeEXT::ePipelines,
+      VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoEXT     info_  = {},
+      const void *                                          pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext{ pNext_ }
+      , type{ type_ }
+      , info{ info_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT( IndirectExecutionSetCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    IndirectExecutionSetCreateInfoEXT( VkIndirectExecutionSetCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+      : IndirectExecutionSetCreateInfoEXT( *reinterpret_cast<IndirectExecutionSetCreateInfoEXT const *>( &rhs ) )
+    {
+    }
+
+    IndirectExecutionSetCreateInfoEXT & operator=( IndirectExecutionSetCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    IndirectExecutionSetCreateInfoEXT & operator=( VkIndirectExecutionSetCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::IndirectExecutionSetCreateInfoEXT const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT & setType( VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoTypeEXT type_ ) VULKAN_HPP_NOEXCEPT
+    {
+      type = type_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT & setInfo( VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoEXT const & info_ ) VULKAN_HPP_NOEXCEPT
+    {
+      info = info_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    operator VkIndirectExecutionSetCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkIndirectExecutionSetCreateInfoEXT *>( this );
+    }
+
+    operator VkIndirectExecutionSetCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkIndirectExecutionSetCreateInfoEXT *>( this );
+    }
+
 #if defined( VULKAN_HPP_USE_REFLECT )
 #  if 14 <= VULKAN_HPP_CPP_VERSION
     auto